//
// File generated by utils/src/rootcint_tmp at Wed Mar  7 17:57:09 2007.
// Do NOT change. Changes will be lost next time file is generated
//

#include "RConfig.h"
#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 "TStreamerInfo.h"
#include "TMemberInspector.h"
#include "TError.h"

#ifndef G__ROOT
#define G__ROOT
#endif

#include "RtypesImp.h"

#include "TCollectionProxy.h"

namespace ROOT {
   namespace Shadow {
   } // Of namespace ROOT::Shadow
} // Of namespace ROOT

namespace ROOT {
   void TGeoAtt_ShowMembers(void *obj, TMemberInspector &R__insp, char *R__parent);
   static TClass *TGeoAtt_IsA(const void*);
   static void *new_TGeoAtt(void *p = 0);
   static void *newArray_TGeoAtt(Long_t size);
   static void delete_TGeoAtt(void *p);
   static void deleteArray_TGeoAtt(void *p);
   static void destruct_TGeoAtt(void *p);

   // Function generating the singleton type initializer
   TGenericClassInfo *GenerateInitInstance(const ::TGeoAtt*)
   {
      ::TGeoAtt *ptr = 0;
      static ::ROOT::TGenericClassInfo 
         instance("TGeoAtt", ::TGeoAtt::Class_Version(), "geom/inc/TGeoAtt.h", 27,
                  typeid(::TGeoAtt), DefineBehavior(ptr, ptr),
                  &::TGeoAtt::Dictionary, &TGeoAtt_IsA, 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;
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstance((const ::TGeoAtt*)0x0); R__UseDummy(_R__UNIQUE_(Init));
}

namespace ROOT {
   void TGeoShape_ShowMembers(void *obj, TMemberInspector &R__insp, char *R__parent);
   static TClass *TGeoShape_IsA(const void*);
   static void delete_TGeoShape(void *p);
   static void deleteArray_TGeoShape(void *p);
   static void destruct_TGeoShape(void *p);

   // Function generating the singleton type initializer
   TGenericClassInfo *GenerateInitInstance(const ::TGeoShape*)
   {
      ::TGeoShape *ptr = 0;
      static ::ROOT::TGenericClassInfo 
         instance("TGeoShape", ::TGeoShape::Class_Version(), "geom/inc/TGeoShape.h", 35,
                  typeid(::TGeoShape), DefineBehavior(ptr, ptr),
                  &::TGeoShape::Dictionary, &TGeoShape_IsA, 4,
                  sizeof(::TGeoShape) );
      instance.SetDelete(&delete_TGeoShape);
      instance.SetDeleteArray(&deleteArray_TGeoShape);
      instance.SetDestructor(&destruct_TGeoShape);
      return &instance;
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstance((const ::TGeoShape*)0x0); R__UseDummy(_R__UNIQUE_(Init));
}

namespace ROOT {
   void TGeoMatrix_ShowMembers(void *obj, TMemberInspector &R__insp, char *R__parent);
   static TClass *TGeoMatrix_IsA(const void*);
   static void delete_TGeoMatrix(void *p);
   static void deleteArray_TGeoMatrix(void *p);
   static void destruct_TGeoMatrix(void *p);

   // Function generating the singleton type initializer
   TGenericClassInfo *GenerateInitInstance(const ::TGeoMatrix*)
   {
      ::TGeoMatrix *ptr = 0;
      static ::ROOT::TGenericClassInfo 
         instance("TGeoMatrix", ::TGeoMatrix::Class_Version(), "geom/inc/TGeoMatrix.h", 41,
                  typeid(::TGeoMatrix), DefineBehavior(ptr, ptr),
                  &::TGeoMatrix::Dictionary, &TGeoMatrix_IsA, 4,
                  sizeof(::TGeoMatrix) );
      instance.SetDelete(&delete_TGeoMatrix);
      instance.SetDeleteArray(&deleteArray_TGeoMatrix);
      instance.SetDestructor(&destruct_TGeoMatrix);
      return &instance;
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstance((const ::TGeoMatrix*)0x0); R__UseDummy(_R__UNIQUE_(Init));
}

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

   // Function generating the singleton type initializer
   TGenericClassInfo *GenerateInitInstance(const ::TGeoHMatrix*)
   {
      ::TGeoHMatrix *ptr = 0;
      static ::ROOT::TGenericClassInfo 
         instance("TGeoHMatrix", ::TGeoHMatrix::Class_Version(), "geom/inc/TGeoMatrix.h", 371,
                  typeid(::TGeoHMatrix), DefineBehavior(ptr, ptr),
                  &::TGeoHMatrix::Dictionary, &TGeoHMatrix_IsA, 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;
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstance((const ::TGeoHMatrix*)0x0); R__UseDummy(_R__UNIQUE_(Init));
}

namespace ROOT {
   void TGeoBoolNode_ShowMembers(void *obj, TMemberInspector &R__insp, char *R__parent);
   static TClass *TGeoBoolNode_IsA(const void*);
   static void delete_TGeoBoolNode(void *p);
   static void deleteArray_TGeoBoolNode(void *p);
   static void destruct_TGeoBoolNode(void *p);

   // Function generating the singleton type initializer
   TGenericClassInfo *GenerateInitInstance(const ::TGeoBoolNode*)
   {
      ::TGeoBoolNode *ptr = 0;
      static ::ROOT::TGenericClassInfo 
         instance("TGeoBoolNode", ::TGeoBoolNode::Class_Version(), "geom/inc/TGeoBoolNode.h", 33,
                  typeid(::TGeoBoolNode), DefineBehavior(ptr, ptr),
                  &::TGeoBoolNode::Dictionary, &TGeoBoolNode_IsA, 4,
                  sizeof(::TGeoBoolNode) );
      instance.SetDelete(&delete_TGeoBoolNode);
      instance.SetDeleteArray(&deleteArray_TGeoBoolNode);
      instance.SetDestructor(&destruct_TGeoBoolNode);
      return &instance;
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstance((const ::TGeoBoolNode*)0x0); R__UseDummy(_R__UNIQUE_(Init));
}

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

   // Function generating the singleton type initializer
   TGenericClassInfo *GenerateInitInstance(const ::TGeoUnion*)
   {
      ::TGeoUnion *ptr = 0;
      static ::ROOT::TGenericClassInfo 
         instance("TGeoUnion", ::TGeoUnion::Class_Version(), "geom/inc/TGeoBoolNode.h", 89,
                  typeid(::TGeoUnion), DefineBehavior(ptr, ptr),
                  &::TGeoUnion::Dictionary, &TGeoUnion_IsA, 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;
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstance((const ::TGeoUnion*)0x0); R__UseDummy(_R__UNIQUE_(Init));
}

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

   // Function generating the singleton type initializer
   TGenericClassInfo *GenerateInitInstance(const ::TGeoIntersection*)
   {
      ::TGeoIntersection *ptr = 0;
      static ::ROOT::TGenericClassInfo 
         instance("TGeoIntersection", ::TGeoIntersection::Class_Version(), "geom/inc/TGeoBoolNode.h", 128,
                  typeid(::TGeoIntersection), DefineBehavior(ptr, ptr),
                  &::TGeoIntersection::Dictionary, &TGeoIntersection_IsA, 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;
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstance((const ::TGeoIntersection*)0x0); R__UseDummy(_R__UNIQUE_(Init));
}

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

   // Function generating the singleton type initializer
   TGenericClassInfo *GenerateInitInstance(const ::TGeoSubtraction*)
   {
      ::TGeoSubtraction *ptr = 0;
      static ::ROOT::TGenericClassInfo 
         instance("TGeoSubtraction", ::TGeoSubtraction::Class_Version(), "geom/inc/TGeoBoolNode.h", 168,
                  typeid(::TGeoSubtraction), DefineBehavior(ptr, ptr),
                  &::TGeoSubtraction::Dictionary, &TGeoSubtraction_IsA, 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;
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstance((const ::TGeoSubtraction*)0x0); R__UseDummy(_R__UNIQUE_(Init));
}

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

   // Function generating the singleton type initializer
   TGenericClassInfo *GenerateInitInstance(const ::TGeoElementTable*)
   {
      ::TGeoElementTable *ptr = 0;
      static ::ROOT::TGenericClassInfo 
         instance("TGeoElementTable", ::TGeoElementTable::Class_Version(), "geom/inc/TGeoElement.h", 68,
                  typeid(::TGeoElementTable), DefineBehavior(ptr, ptr),
                  &::TGeoElementTable::Dictionary, &TGeoElementTable_IsA, 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;
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstance((const ::TGeoElementTable*)0x0); R__UseDummy(_R__UNIQUE_(Init));
}

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

   // Function generating the singleton type initializer
   TGenericClassInfo *GenerateInitInstance(const ::TGeoElement*)
   {
      ::TGeoElement *ptr = 0;
      static ::ROOT::TGenericClassInfo 
         instance("TGeoElement", ::TGeoElement::Class_Version(), "geom/inc/TGeoElement.h", 31,
                  typeid(::TGeoElement), DefineBehavior(ptr, ptr),
                  &::TGeoElement::Dictionary, &TGeoElement_IsA, 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;
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstance((const ::TGeoElement*)0x0); R__UseDummy(_R__UNIQUE_(Init));
}

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

   // Function generating the singleton type initializer
   TGenericClassInfo *GenerateInitInstance(const ::TGeoMaterial*)
   {
      ::TGeoMaterial *ptr = 0;
      static ::ROOT::TGenericClassInfo 
         instance("TGeoMaterial", ::TGeoMaterial::Class_Version(), "geom/inc/TGeoMaterial.h", 45,
                  typeid(::TGeoMaterial), DefineBehavior(ptr, ptr),
                  &::TGeoMaterial::Dictionary, &TGeoMaterial_IsA, 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;
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstance((const ::TGeoMaterial*)0x0); R__UseDummy(_R__UNIQUE_(Init));
}

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

   // Function generating the singleton type initializer
   TGenericClassInfo *GenerateInitInstance(const ::TGeoMixture*)
   {
      ::TGeoMixture *ptr = 0;
      static ::ROOT::TGenericClassInfo 
         instance("TGeoMixture", ::TGeoMixture::Class_Version(), "geom/inc/TGeoMaterial.h", 113,
                  typeid(::TGeoMixture), DefineBehavior(ptr, ptr),
                  &::TGeoMixture::Dictionary, &TGeoMixture_IsA, 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;
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstance((const ::TGeoMixture*)0x0); R__UseDummy(_R__UNIQUE_(Init));
}

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

   // Function generating the singleton type initializer
   TGenericClassInfo *GenerateInitInstance(const ::TGeoMedium*)
   {
      ::TGeoMedium *ptr = 0;
      static ::ROOT::TGenericClassInfo 
         instance("TGeoMedium", ::TGeoMedium::Class_Version(), "geom/inc/TGeoMedium.h", 25,
                  typeid(::TGeoMedium), DefineBehavior(ptr, ptr),
                  &::TGeoMedium::Dictionary, &TGeoMedium_IsA, 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;
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstance((const ::TGeoMedium*)0x0); R__UseDummy(_R__UNIQUE_(Init));
}

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

   // Function generating the singleton type initializer
   TGenericClassInfo *GenerateInitInstance(const ::TGeoTranslation*)
   {
      ::TGeoTranslation *ptr = 0;
      static ::ROOT::TGenericClassInfo 
         instance("TGeoTranslation", ::TGeoTranslation::Class_Version(), "geom/inc/TGeoMatrix.h", 113,
                  typeid(::TGeoTranslation), DefineBehavior(ptr, ptr),
                  &::TGeoTranslation::Dictionary, &TGeoTranslation_IsA, 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;
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstance((const ::TGeoTranslation*)0x0); R__UseDummy(_R__UNIQUE_(Init));
}

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

   // Function generating the singleton type initializer
   TGenericClassInfo *GenerateInitInstance(const ::TGeoRotation*)
   {
      ::TGeoRotation *ptr = 0;
      static ::ROOT::TGenericClassInfo 
         instance("TGeoRotation", ::TGeoRotation::Class_Version(), "geom/inc/TGeoMatrix.h", 160,
                  typeid(::TGeoRotation), DefineBehavior(ptr, ptr),
                  &::TGeoRotation::Dictionary, &TGeoRotation_IsA, 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;
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstance((const ::TGeoRotation*)0x0); R__UseDummy(_R__UNIQUE_(Init));
}

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

   // Function generating the singleton type initializer
   TGenericClassInfo *GenerateInitInstance(const ::TGeoScale*)
   {
      ::TGeoScale *ptr = 0;
      static ::ROOT::TGenericClassInfo 
         instance("TGeoScale", ::TGeoScale::Class_Version(), "geom/inc/TGeoMatrix.h", 224,
                  typeid(::TGeoScale), DefineBehavior(ptr, ptr),
                  &::TGeoScale::Dictionary, &TGeoScale_IsA, 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;
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstance((const ::TGeoScale*)0x0); R__UseDummy(_R__UNIQUE_(Init));
}

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

   // Function generating the singleton type initializer
   TGenericClassInfo *GenerateInitInstance(const ::TGeoCombiTrans*)
   {
      ::TGeoCombiTrans *ptr = 0;
      static ::ROOT::TGenericClassInfo 
         instance("TGeoCombiTrans", ::TGeoCombiTrans::Class_Version(), "geom/inc/TGeoMatrix.h", 252,
                  typeid(::TGeoCombiTrans), DefineBehavior(ptr, ptr),
                  &::TGeoCombiTrans::Dictionary, &TGeoCombiTrans_IsA, 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;
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstance((const ::TGeoCombiTrans*)0x0); R__UseDummy(_R__UNIQUE_(Init));
}

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

   // Function generating the singleton type initializer
   TGenericClassInfo *GenerateInitInstance(const ::TGeoGenTrans*)
   {
      ::TGeoGenTrans *ptr = 0;
      static ::ROOT::TGenericClassInfo 
         instance("TGeoGenTrans", ::TGeoGenTrans::Class_Version(), "geom/inc/TGeoMatrix.h", 299,
                  typeid(::TGeoGenTrans), DefineBehavior(ptr, ptr),
                  &::TGeoGenTrans::Dictionary, &TGeoGenTrans_IsA, 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;
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstance((const ::TGeoGenTrans*)0x0); R__UseDummy(_R__UNIQUE_(Init));
}

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

   // Function generating the singleton type initializer
   TGenericClassInfo *GenerateInitInstance(const ::TGeoIdentity*)
   {
      ::TGeoIdentity *ptr = 0;
      static ::ROOT::TGenericClassInfo 
         instance("TGeoIdentity", ::TGeoIdentity::Class_Version(), "geom/inc/TGeoMatrix.h", 331,
                  typeid(::TGeoIdentity), DefineBehavior(ptr, ptr),
                  &::TGeoIdentity::Dictionary, &TGeoIdentity_IsA, 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;
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstance((const ::TGeoIdentity*)0x0); R__UseDummy(_R__UNIQUE_(Init));
}

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

   // Function generating the singleton type initializer
   TGenericClassInfo *GenerateInitInstance(const ::TGeoBBox*)
   {
      ::TGeoBBox *ptr = 0;
      static ::ROOT::TGenericClassInfo 
         instance("TGeoBBox", ::TGeoBBox::Class_Version(), "geom/inc/TGeoBBox.h", 29,
                  typeid(::TGeoBBox), DefineBehavior(ptr, ptr),
                  &::TGeoBBox::Dictionary, &TGeoBBox_IsA, 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;
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstance((const ::TGeoBBox*)0x0); R__UseDummy(_R__UNIQUE_(Init));
}

namespace ROOT {
   void TGeoVolume_ShowMembers(void *obj, TMemberInspector &R__insp, char *R__parent);
   static TClass *TGeoVolume_IsA(const void*);
   static void *new_TGeoVolume(void *p = 0);
   static void *newArray_TGeoVolume(Long_t size);
   static void delete_TGeoVolume(void *p);
   static void deleteArray_TGeoVolume(void *p);
   static void destruct_TGeoVolume(void *p);

   // Function generating the singleton type initializer
   TGenericClassInfo *GenerateInitInstance(const ::TGeoVolume*)
   {
      ::TGeoVolume *ptr = 0;
      static ::ROOT::TGenericClassInfo 
         instance("TGeoVolume", ::TGeoVolume::Class_Version(), "geom/inc/TGeoVolume.h", 63,
                  typeid(::TGeoVolume), DefineBehavior(ptr, ptr),
                  &::TGeoVolume::Dictionary, &TGeoVolume_IsA, 1,
                  sizeof(::TGeoVolume) );
      instance.SetNew(&new_TGeoVolume);
      instance.SetNewArray(&newArray_TGeoVolume);
      instance.SetDelete(&delete_TGeoVolume);
      instance.SetDeleteArray(&deleteArray_TGeoVolume);
      instance.SetDestructor(&destruct_TGeoVolume);
      return &instance;
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstance((const ::TGeoVolume*)0x0); R__UseDummy(_R__UNIQUE_(Init));
}

namespace ROOT {
   void TGeoNode_ShowMembers(void *obj, TMemberInspector &R__insp, char *R__parent);
   static TClass *TGeoNode_IsA(const void*);
   static void delete_TGeoNode(void *p);
   static void deleteArray_TGeoNode(void *p);
   static void destruct_TGeoNode(void *p);

   // Function generating the singleton type initializer
   TGenericClassInfo *GenerateInitInstance(const ::TGeoNode*)
   {
      ::TGeoNode *ptr = 0;
      static ::ROOT::TGenericClassInfo 
         instance("TGeoNode", ::TGeoNode::Class_Version(), "geom/inc/TGeoNode.h", 53,
                  typeid(::TGeoNode), DefineBehavior(ptr, ptr),
                  &::TGeoNode::Dictionary, &TGeoNode_IsA, 4,
                  sizeof(::TGeoNode) );
      instance.SetDelete(&delete_TGeoNode);
      instance.SetDeleteArray(&deleteArray_TGeoNode);
      instance.SetDestructor(&destruct_TGeoNode);
      return &instance;
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstance((const ::TGeoNode*)0x0); R__UseDummy(_R__UNIQUE_(Init));
}

namespace ROOT {
   void TGeoVoxelFinder_ShowMembers(void *obj, TMemberInspector &R__insp, char *R__parent);
   static TClass *TGeoVoxelFinder_IsA(const void*);
   static void *new_TGeoVoxelFinder(void *p = 0);
   static void *newArray_TGeoVoxelFinder(Long_t size);
   static void delete_TGeoVoxelFinder(void *p);
   static void deleteArray_TGeoVoxelFinder(void *p);
   static void destruct_TGeoVoxelFinder(void *p);

   // Function generating the singleton type initializer
   TGenericClassInfo *GenerateInitInstance(const ::TGeoVoxelFinder*)
   {
      ::TGeoVoxelFinder *ptr = 0;
      static ::ROOT::TGenericClassInfo 
         instance("TGeoVoxelFinder", ::TGeoVoxelFinder::Class_Version(), "geom/inc/TGeoVoxelFinder.h", 25,
                  typeid(::TGeoVoxelFinder), DefineBehavior(ptr, ptr),
                  &::TGeoVoxelFinder::Dictionary, &TGeoVoxelFinder_IsA, 4,
                  sizeof(::TGeoVoxelFinder) );
      instance.SetNew(&new_TGeoVoxelFinder);
      instance.SetNewArray(&newArray_TGeoVoxelFinder);
      instance.SetDelete(&delete_TGeoVoxelFinder);
      instance.SetDeleteArray(&deleteArray_TGeoVoxelFinder);
      instance.SetDestructor(&destruct_TGeoVoxelFinder);
      return &instance;
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstance((const ::TGeoVoxelFinder*)0x0); R__UseDummy(_R__UNIQUE_(Init));
}

namespace ROOT {
   void TGeoManager_ShowMembers(void *obj, TMemberInspector &R__insp, char *R__parent);
   static TClass *TGeoManager_IsA(const void*);
   static void *new_TGeoManager(void *p = 0);
   static void *newArray_TGeoManager(Long_t size);
   static void delete_TGeoManager(void *p);
   static void deleteArray_TGeoManager(void *p);
   static void destruct_TGeoManager(void *p);

   // Function generating the singleton type initializer
   TGenericClassInfo *GenerateInitInstance(const ::TGeoManager*)
   {
      ::TGeoManager *ptr = 0;
      static ::ROOT::TGenericClassInfo 
         instance("TGeoManager", ::TGeoManager::Class_Version(), "geom/inc/TGeoManager.h", 42,
                  typeid(::TGeoManager), DefineBehavior(ptr, ptr),
                  &::TGeoManager::Dictionary, &TGeoManager_IsA, 1,
                  sizeof(::TGeoManager) );
      instance.SetNew(&new_TGeoManager);
      instance.SetNewArray(&newArray_TGeoManager);
      instance.SetDelete(&delete_TGeoManager);
      instance.SetDeleteArray(&deleteArray_TGeoManager);
      instance.SetDestructor(&destruct_TGeoManager);
      return &instance;
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstance((const ::TGeoManager*)0x0); R__UseDummy(_R__UNIQUE_(Init));
}

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

   // Function generating the singleton type initializer
   TGenericClassInfo *GenerateInitInstance(const ::TGeoVolumeMulti*)
   {
      ::TGeoVolumeMulti *ptr = 0;
      static ::ROOT::TGenericClassInfo 
         instance("TGeoVolumeMulti", ::TGeoVolumeMulti::Class_Version(), "geom/inc/TGeoVolume.h", 205,
                  typeid(::TGeoVolumeMulti), DefineBehavior(ptr, ptr),
                  &::TGeoVolumeMulti::Dictionary, &TGeoVolumeMulti_IsA, 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;
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstance((const ::TGeoVolumeMulti*)0x0); R__UseDummy(_R__UNIQUE_(Init));
}

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

   // Function generating the singleton type initializer
   TGenericClassInfo *GenerateInitInstance(const ::TGeoVolumeAssembly*)
   {
      ::TGeoVolumeAssembly *ptr = 0;
      static ::ROOT::TGenericClassInfo 
         instance("TGeoVolumeAssembly", ::TGeoVolumeAssembly::Class_Version(), "geom/inc/TGeoVolume.h", 250,
                  typeid(::TGeoVolumeAssembly), DefineBehavior(ptr, ptr),
                  &::TGeoVolumeAssembly::Dictionary, &TGeoVolumeAssembly_IsA, 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;
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstance((const ::TGeoVolumeAssembly*)0x0); R__UseDummy(_R__UNIQUE_(Init));
}

namespace ROOT {
   void TGeoCylVoxels_ShowMembers(void *obj, TMemberInspector &R__insp, char *R__parent);
   static TClass *TGeoCylVoxels_IsA(const void*);
   static void *new_TGeoCylVoxels(void *p = 0);
   static void *newArray_TGeoCylVoxels(Long_t size);
   static void delete_TGeoCylVoxels(void *p);
   static void deleteArray_TGeoCylVoxels(void *p);
   static void destruct_TGeoCylVoxels(void *p);

   // Function generating the singleton type initializer
   TGenericClassInfo *GenerateInitInstance(const ::TGeoCylVoxels*)
   {
      ::TGeoCylVoxels *ptr = 0;
      static ::ROOT::TGenericClassInfo 
         instance("TGeoCylVoxels", ::TGeoCylVoxels::Class_Version(), "geom/inc/TGeoVoxelFinder.h", 132,
                  typeid(::TGeoCylVoxels), DefineBehavior(ptr, ptr),
                  &::TGeoCylVoxels::Dictionary, &TGeoCylVoxels_IsA, 4,
                  sizeof(::TGeoCylVoxels) );
      instance.SetNew(&new_TGeoCylVoxels);
      instance.SetNewArray(&newArray_TGeoCylVoxels);
      instance.SetDelete(&delete_TGeoCylVoxels);
      instance.SetDeleteArray(&deleteArray_TGeoCylVoxels);
      instance.SetDestructor(&destruct_TGeoCylVoxels);
      return &instance;
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstance((const ::TGeoCylVoxels*)0x0); R__UseDummy(_R__UNIQUE_(Init));
}

namespace ROOT {
   void TGeoFullVoxels_ShowMembers(void *obj, TMemberInspector &R__insp, char *R__parent);
   static TClass *TGeoFullVoxels_IsA(const void*);
   static void *new_TGeoFullVoxels(void *p = 0);
   static void *newArray_TGeoFullVoxels(Long_t size);
   static void delete_TGeoFullVoxels(void *p);
   static void deleteArray_TGeoFullVoxels(void *p);
   static void destruct_TGeoFullVoxels(void *p);

   // Function generating the singleton type initializer
   TGenericClassInfo *GenerateInitInstance(const ::TGeoFullVoxels*)
   {
      ::TGeoFullVoxels *ptr = 0;
      static ::ROOT::TGenericClassInfo 
         instance("TGeoFullVoxels", ::TGeoFullVoxels::Class_Version(), "geom/inc/TGeoVoxelFinder.h", 161,
                  typeid(::TGeoFullVoxels), DefineBehavior(ptr, ptr),
                  &::TGeoFullVoxels::Dictionary, &TGeoFullVoxels_IsA, 4,
                  sizeof(::TGeoFullVoxels) );
      instance.SetNew(&new_TGeoFullVoxels);
      instance.SetNewArray(&newArray_TGeoFullVoxels);
      instance.SetDelete(&delete_TGeoFullVoxels);
      instance.SetDeleteArray(&deleteArray_TGeoFullVoxels);
      instance.SetDestructor(&destruct_TGeoFullVoxels);
      return &instance;
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstance((const ::TGeoFullVoxels*)0x0); R__UseDummy(_R__UNIQUE_(Init));
}

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

   // Function generating the singleton type initializer
   TGenericClassInfo *GenerateInitInstance(const ::TGeoNodeMatrix*)
   {
      ::TGeoNodeMatrix *ptr = 0;
      static ::ROOT::TGenericClassInfo 
         instance("TGeoNodeMatrix", ::TGeoNodeMatrix::Class_Version(), "geom/inc/TGeoNode.h", 140,
                  typeid(::TGeoNodeMatrix), DefineBehavior(ptr, ptr),
                  &::TGeoNodeMatrix::Dictionary, &TGeoNodeMatrix_IsA, 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;
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstance((const ::TGeoNodeMatrix*)0x0); R__UseDummy(_R__UNIQUE_(Init));
}

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

   // Function generating the singleton type initializer
   TGenericClassInfo *GenerateInitInstance(const ::TGeoNodeOffset*)
   {
      ::TGeoNodeOffset *ptr = 0;
      static ::ROOT::TGenericClassInfo 
         instance("TGeoNodeOffset", ::TGeoNodeOffset::Class_Version(), "geom/inc/TGeoNode.h", 167,
                  typeid(::TGeoNodeOffset), DefineBehavior(ptr, ptr),
                  &::TGeoNodeOffset::Dictionary, &TGeoNodeOffset_IsA, 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;
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstance((const ::TGeoNodeOffset*)0x0); R__UseDummy(_R__UNIQUE_(Init));
}

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

   // Function generating the singleton type initializer
   TGenericClassInfo *GenerateInitInstance(const ::TGeoPara*)
   {
      ::TGeoPara *ptr = 0;
      static ::ROOT::TGenericClassInfo 
         instance("TGeoPara", ::TGeoPara::Class_Version(), "geom/inc/TGeoPara.h", 30,
                  typeid(::TGeoPara), DefineBehavior(ptr, ptr),
                  &::TGeoPara::Dictionary, &TGeoPara_IsA, 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;
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstance((const ::TGeoPara*)0x0); R__UseDummy(_R__UNIQUE_(Init));
}

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

   // Function generating the singleton type initializer
   TGenericClassInfo *GenerateInitInstance(const ::TGeoTube*)
   {
      ::TGeoTube *ptr = 0;
      static ::ROOT::TGenericClassInfo 
         instance("TGeoTube", ::TGeoTube::Class_Version(), "geom/inc/TGeoTube.h", 29,
                  typeid(::TGeoTube), DefineBehavior(ptr, ptr),
                  &::TGeoTube::Dictionary, &TGeoTube_IsA, 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;
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstance((const ::TGeoTube*)0x0); R__UseDummy(_R__UNIQUE_(Init));
}

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

   // Function generating the singleton type initializer
   TGenericClassInfo *GenerateInitInstance(const ::TGeoTubeSeg*)
   {
      ::TGeoTubeSeg *ptr = 0;
      static ::ROOT::TGenericClassInfo 
         instance("TGeoTubeSeg", ::TGeoTubeSeg::Class_Version(), "geom/inc/TGeoTube.h", 99,
                  typeid(::TGeoTubeSeg), DefineBehavior(ptr, ptr),
                  &::TGeoTubeSeg::Dictionary, &TGeoTubeSeg_IsA, 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;
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstance((const ::TGeoTubeSeg*)0x0); R__UseDummy(_R__UNIQUE_(Init));
}

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

   // Function generating the singleton type initializer
   TGenericClassInfo *GenerateInitInstance(const ::TGeoCtub*)
   {
      ::TGeoCtub *ptr = 0;
      static ::ROOT::TGenericClassInfo 
         instance("TGeoCtub", ::TGeoCtub::Class_Version(), "geom/inc/TGeoTube.h", 168,
                  typeid(::TGeoCtub), DefineBehavior(ptr, ptr),
                  &::TGeoCtub::Dictionary, &TGeoCtub_IsA, 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;
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstance((const ::TGeoCtub*)0x0); R__UseDummy(_R__UNIQUE_(Init));
}

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

   // Function generating the singleton type initializer
   TGenericClassInfo *GenerateInitInstance(const ::TGeoTorus*)
   {
      ::TGeoTorus *ptr = 0;
      static ::ROOT::TGenericClassInfo 
         instance("TGeoTorus", ::TGeoTorus::Class_Version(), "geom/inc/TGeoTorus.h", 31,
                  typeid(::TGeoTorus), DefineBehavior(ptr, ptr),
                  &::TGeoTorus::Dictionary, &TGeoTorus_IsA, 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;
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstance((const ::TGeoTorus*)0x0); R__UseDummy(_R__UNIQUE_(Init));
}

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

   // Function generating the singleton type initializer
   TGenericClassInfo *GenerateInitInstance(const ::TGeoSphere*)
   {
      ::TGeoSphere *ptr = 0;
      static ::ROOT::TGenericClassInfo 
         instance("TGeoSphere", ::TGeoSphere::Class_Version(), "geom/inc/TGeoSphere.h", 29,
                  typeid(::TGeoSphere), DefineBehavior(ptr, ptr),
                  &::TGeoSphere::Dictionary, &TGeoSphere_IsA, 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;
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstance((const ::TGeoSphere*)0x0); R__UseDummy(_R__UNIQUE_(Init));
}

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

   // Function generating the singleton type initializer
   TGenericClassInfo *GenerateInitInstance(const ::TGeoEltu*)
   {
      ::TGeoEltu *ptr = 0;
      static ::ROOT::TGenericClassInfo 
         instance("TGeoEltu", ::TGeoEltu::Class_Version(), "geom/inc/TGeoEltu.h", 28,
                  typeid(::TGeoEltu), DefineBehavior(ptr, ptr),
                  &::TGeoEltu::Dictionary, &TGeoEltu_IsA, 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;
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstance((const ::TGeoEltu*)0x0); R__UseDummy(_R__UNIQUE_(Init));
}

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

   // Function generating the singleton type initializer
   TGenericClassInfo *GenerateInitInstance(const ::TGeoHype*)
   {
      ::TGeoHype *ptr = 0;
      static ::ROOT::TGenericClassInfo 
         instance("TGeoHype", ::TGeoHype::Class_Version(), "geom/inc/TGeoHype.h", 48,
                  typeid(::TGeoHype), DefineBehavior(ptr, ptr),
                  &::TGeoHype::Dictionary, &TGeoHype_IsA, 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;
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstance((const ::TGeoHype*)0x0); R__UseDummy(_R__UNIQUE_(Init));
}

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

   // Function generating the singleton type initializer
   TGenericClassInfo *GenerateInitInstance(const ::TGeoCone*)
   {
      ::TGeoCone *ptr = 0;
      static ::ROOT::TGenericClassInfo 
         instance("TGeoCone", ::TGeoCone::Class_Version(), "geom/inc/TGeoCone.h", 31,
                  typeid(::TGeoCone), DefineBehavior(ptr, ptr),
                  &::TGeoCone::Dictionary, &TGeoCone_IsA, 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;
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstance((const ::TGeoCone*)0x0); R__UseDummy(_R__UNIQUE_(Init));
}

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

   // Function generating the singleton type initializer
   TGenericClassInfo *GenerateInitInstance(const ::TGeoConeSeg*)
   {
      ::TGeoConeSeg *ptr = 0;
      static ::ROOT::TGenericClassInfo 
         instance("TGeoConeSeg", ::TGeoConeSeg::Class_Version(), "geom/inc/TGeoCone.h", 111,
                  typeid(::TGeoConeSeg), DefineBehavior(ptr, ptr),
                  &::TGeoConeSeg::Dictionary, &TGeoConeSeg_IsA, 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;
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstance((const ::TGeoConeSeg*)0x0); R__UseDummy(_R__UNIQUE_(Init));
}

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

   // Function generating the singleton type initializer
   TGenericClassInfo *GenerateInitInstance(const ::TGeoPcon*)
   {
      ::TGeoPcon *ptr = 0;
      static ::ROOT::TGenericClassInfo 
         instance("TGeoPcon", ::TGeoPcon::Class_Version(), "geom/inc/TGeoPcon.h", 31,
                  typeid(::TGeoPcon), DefineBehavior(ptr, ptr),
                  &::TGeoPcon::Dictionary, &TGeoPcon_IsA, 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;
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstance((const ::TGeoPcon*)0x0); R__UseDummy(_R__UNIQUE_(Init));
}

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

   // Function generating the singleton type initializer
   TGenericClassInfo *GenerateInitInstance(const ::TGeoPgon*)
   {
      ::TGeoPgon *ptr = 0;
      static ::ROOT::TGenericClassInfo 
         instance("TGeoPgon", ::TGeoPgon::Class_Version(), "geom/inc/TGeoPgon.h", 32,
                  typeid(::TGeoPgon), DefineBehavior(ptr, ptr),
                  &::TGeoPgon::Dictionary, &TGeoPgon_IsA, 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;
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstance((const ::TGeoPgon*)0x0); R__UseDummy(_R__UNIQUE_(Init));
}

namespace ROOT {
   void TGeoArb8_ShowMembers(void *obj, TMemberInspector &R__insp, char *R__parent);
   static TClass *TGeoArb8_IsA(const void*);
   static void *new_TGeoArb8(void *p = 0);
   static void *newArray_TGeoArb8(Long_t size);
   static void delete_TGeoArb8(void *p);
   static void deleteArray_TGeoArb8(void *p);
   static void destruct_TGeoArb8(void *p);

   // Function generating the singleton type initializer
   TGenericClassInfo *GenerateInitInstance(const ::TGeoArb8*)
   {
      ::TGeoArb8 *ptr = 0;
      static ::ROOT::TGenericClassInfo 
         instance("TGeoArb8", ::TGeoArb8::Class_Version(), "geom/inc/TGeoArb8.h", 44,
                  typeid(::TGeoArb8), DefineBehavior(ptr, ptr),
                  &::TGeoArb8::Dictionary, &TGeoArb8_IsA, 4,
                  sizeof(::TGeoArb8) );
      instance.SetNew(&new_TGeoArb8);
      instance.SetNewArray(&newArray_TGeoArb8);
      instance.SetDelete(&delete_TGeoArb8);
      instance.SetDeleteArray(&deleteArray_TGeoArb8);
      instance.SetDestructor(&destruct_TGeoArb8);
      return &instance;
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstance((const ::TGeoArb8*)0x0); R__UseDummy(_R__UNIQUE_(Init));
}

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

   // Function generating the singleton type initializer
   TGenericClassInfo *GenerateInitInstance(const ::TGeoTrap*)
   {
      ::TGeoTrap *ptr = 0;
      static ::ROOT::TGenericClassInfo 
         instance("TGeoTrap", ::TGeoTrap::Class_Version(), "geom/inc/TGeoArb8.h", 120,
                  typeid(::TGeoTrap), DefineBehavior(ptr, ptr),
                  &::TGeoTrap::Dictionary, &TGeoTrap_IsA, 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;
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstance((const ::TGeoTrap*)0x0); R__UseDummy(_R__UNIQUE_(Init));
}

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

   // Function generating the singleton type initializer
   TGenericClassInfo *GenerateInitInstance(const ::TGeoGtra*)
   {
      ::TGeoGtra *ptr = 0;
      static ::ROOT::TGenericClassInfo 
         instance("TGeoGtra", ::TGeoGtra::Class_Version(), "geom/inc/TGeoArb8.h", 186,
                  typeid(::TGeoGtra), DefineBehavior(ptr, ptr),
                  &::TGeoGtra::Dictionary, &TGeoGtra_IsA, 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;
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstance((const ::TGeoGtra*)0x0); R__UseDummy(_R__UNIQUE_(Init));
}

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

   // Function generating the singleton type initializer
   TGenericClassInfo *GenerateInitInstance(const ::TGeoTrd1*)
   {
      ::TGeoTrd1 *ptr = 0;
      static ::ROOT::TGenericClassInfo 
         instance("TGeoTrd1", ::TGeoTrd1::Class_Version(), "geom/inc/TGeoTrd1.h", 28,
                  typeid(::TGeoTrd1), DefineBehavior(ptr, ptr),
                  &::TGeoTrd1::Dictionary, &TGeoTrd1_IsA, 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;
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstance((const ::TGeoTrd1*)0x0); R__UseDummy(_R__UNIQUE_(Init));
}

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

   // Function generating the singleton type initializer
   TGenericClassInfo *GenerateInitInstance(const ::TGeoTrd2*)
   {
      ::TGeoTrd2 *ptr = 0;
      static ::ROOT::TGenericClassInfo 
         instance("TGeoTrd2", ::TGeoTrd2::Class_Version(), "geom/inc/TGeoTrd2.h", 28,
                  typeid(::TGeoTrd2), DefineBehavior(ptr, ptr),
                  &::TGeoTrd2::Dictionary, &TGeoTrd2_IsA, 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;
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstance((const ::TGeoTrd2*)0x0); R__UseDummy(_R__UNIQUE_(Init));
}

namespace ROOT {
   void TVirtualGeoTrack_ShowMembers(void *obj, TMemberInspector &R__insp, char *R__parent);
   static TClass *TVirtualGeoTrack_IsA(const void*);
   static void delete_TVirtualGeoTrack(void *p);
   static void deleteArray_TVirtualGeoTrack(void *p);
   static void destruct_TVirtualGeoTrack(void *p);

   // Function generating the singleton type initializer
   TGenericClassInfo *GenerateInitInstance(const ::TVirtualGeoTrack*)
   {
      ::TVirtualGeoTrack *ptr = 0;
      static ::ROOT::TGenericClassInfo 
         instance("TVirtualGeoTrack", ::TVirtualGeoTrack::Class_Version(), "geom/inc/TVirtualGeoTrack.h", 44,
                  typeid(::TVirtualGeoTrack), DefineBehavior(ptr, ptr),
                  &::TVirtualGeoTrack::Dictionary, &TVirtualGeoTrack_IsA, 4,
                  sizeof(::TVirtualGeoTrack) );
      instance.SetDelete(&delete_TVirtualGeoTrack);
      instance.SetDeleteArray(&deleteArray_TVirtualGeoTrack);
      instance.SetDestructor(&destruct_TVirtualGeoTrack);
      return &instance;
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstance((const ::TVirtualGeoTrack*)0x0); R__UseDummy(_R__UNIQUE_(Init));
}

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

   // Function generating the singleton type initializer
   TGenericClassInfo *GenerateInitInstance(const ::TGeoPhysicalNode*)
   {
      ::TGeoPhysicalNode *ptr = 0;
      static ::ROOT::TGenericClassInfo 
         instance("TGeoPhysicalNode", ::TGeoPhysicalNode::Class_Version(), "geom/inc/TGeoPhysicalNode.h", 43,
                  typeid(::TGeoPhysicalNode), DefineBehavior(ptr, ptr),
                  &::TGeoPhysicalNode::Dictionary, &TGeoPhysicalNode_IsA, 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;
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstance((const ::TGeoPhysicalNode*)0x0); R__UseDummy(_R__UNIQUE_(Init));
}

namespace ROOT {
   void TVirtualGeoPainter_ShowMembers(void *obj, TMemberInspector &R__insp, char *R__parent);
   static TClass *TVirtualGeoPainter_IsA(const void*);
   static void delete_TVirtualGeoPainter(void *p);
   static void deleteArray_TVirtualGeoPainter(void *p);
   static void destruct_TVirtualGeoPainter(void *p);

   // Function generating the singleton type initializer
   TGenericClassInfo *GenerateInitInstance(const ::TVirtualGeoPainter*)
   {
      ::TVirtualGeoPainter *ptr = 0;
      static ::ROOT::TGenericClassInfo 
         instance("TVirtualGeoPainter", ::TVirtualGeoPainter::Class_Version(), "geom/inc/TVirtualGeoPainter.h", 38,
                  typeid(::TVirtualGeoPainter), DefineBehavior(ptr, ptr),
                  &::TVirtualGeoPainter::Dictionary, &TVirtualGeoPainter_IsA, 4,
                  sizeof(::TVirtualGeoPainter) );
      instance.SetDelete(&delete_TVirtualGeoPainter);
      instance.SetDeleteArray(&deleteArray_TVirtualGeoPainter);
      instance.SetDestructor(&destruct_TVirtualGeoPainter);
      return &instance;
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstance((const ::TVirtualGeoPainter*)0x0); R__UseDummy(_R__UNIQUE_(Init));
}

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

   // Function generating the singleton type initializer
   TGenericClassInfo *GenerateInitInstance(const ::TGeoCompositeShape*)
   {
      ::TGeoCompositeShape *ptr = 0;
      static ::ROOT::TGenericClassInfo 
         instance("TGeoCompositeShape", ::TGeoCompositeShape::Class_Version(), "geom/inc/TGeoCompositeShape.h", 30,
                  typeid(::TGeoCompositeShape), DefineBehavior(ptr, ptr),
                  &::TGeoCompositeShape::Dictionary, &TGeoCompositeShape_IsA, 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;
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstance((const ::TGeoCompositeShape*)0x0); R__UseDummy(_R__UNIQUE_(Init));
}

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

   // Function generating the singleton type initializer
   TGenericClassInfo *GenerateInitInstance(const ::TGeoPolygon*)
   {
      ::TGeoPolygon *ptr = 0;
      static ::ROOT::TGenericClassInfo 
         instance("TGeoPolygon", ::TGeoPolygon::Class_Version(), "geom/inc/TGeoPolygon.h", 31,
                  typeid(::TGeoPolygon), DefineBehavior(ptr, ptr),
                  &::TGeoPolygon::Dictionary, &TGeoPolygon_IsA, 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;
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstance((const ::TGeoPolygon*)0x0); R__UseDummy(_R__UNIQUE_(Init));
}

namespace ROOT {
   void TGeoXtru_ShowMembers(void *obj, TMemberInspector &R__insp, char *R__parent);
   static TClass *TGeoXtru_IsA(const void*);
   static void *new_TGeoXtru(void *p = 0);
   static void *newArray_TGeoXtru(Long_t size);
   static void delete_TGeoXtru(void *p);
   static void deleteArray_TGeoXtru(void *p);
   static void destruct_TGeoXtru(void *p);

   // Function generating the singleton type initializer
   TGenericClassInfo *GenerateInitInstance(const ::TGeoXtru*)
   {
      ::TGeoXtru *ptr = 0;
      static ::ROOT::TGenericClassInfo 
         instance("TGeoXtru", ::TGeoXtru::Class_Version(), "geom/inc/TGeoXtru.h", 31,
                  typeid(::TGeoXtru), DefineBehavior(ptr, ptr),
                  &::TGeoXtru::Dictionary, &TGeoXtru_IsA, 4,
                  sizeof(::TGeoXtru) );
      instance.SetNew(&new_TGeoXtru);
      instance.SetNewArray(&newArray_TGeoXtru);
      instance.SetDelete(&delete_TGeoXtru);
      instance.SetDeleteArray(&deleteArray_TGeoXtru);
      instance.SetDestructor(&destruct_TGeoXtru);
      return &instance;
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstance((const ::TGeoXtru*)0x0); R__UseDummy(_R__UNIQUE_(Init));
}

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

   // Function generating the singleton type initializer
   TGenericClassInfo *GenerateInitInstance(const ::TGeoHelix*)
   {
      ::TGeoHelix *ptr = 0;
      static ::ROOT::TGenericClassInfo 
         instance("TGeoHelix", ::TGeoHelix::Class_Version(), "geom/inc/TGeoHelix.h", 38,
                  typeid(::TGeoHelix), DefineBehavior(ptr, ptr),
                  &::TGeoHelix::Dictionary, &TGeoHelix_IsA, 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;
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstance((const ::TGeoHelix*)0x0); R__UseDummy(_R__UNIQUE_(Init));
}

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

   // Function generating the singleton type initializer
   TGenericClassInfo *GenerateInitInstance(const ::TGeoParaboloid*)
   {
      ::TGeoParaboloid *ptr = 0;
      static ::ROOT::TGenericClassInfo 
         instance("TGeoParaboloid", ::TGeoParaboloid::Class_Version(), "geom/inc/TGeoParaboloid.h", 37,
                  typeid(::TGeoParaboloid), DefineBehavior(ptr, ptr),
                  &::TGeoParaboloid::Dictionary, &TGeoParaboloid_IsA, 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;
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstance((const ::TGeoParaboloid*)0x0); R__UseDummy(_R__UNIQUE_(Init));
}

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

   // Function generating the singleton type initializer
   TGenericClassInfo *GenerateInitInstance(const ::TGeoHalfSpace*)
   {
      ::TGeoHalfSpace *ptr = 0;
      static ::ROOT::TGenericClassInfo 
         instance("TGeoHalfSpace", ::TGeoHalfSpace::Class_Version(), "geom/inc/TGeoHalfSpace.h", 30,
                  typeid(::TGeoHalfSpace), DefineBehavior(ptr, ptr),
                  &::TGeoHalfSpace::Dictionary, &TGeoHalfSpace_IsA, 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;
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstance((const ::TGeoHalfSpace*)0x0); R__UseDummy(_R__UNIQUE_(Init));
}

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

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

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

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

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

//______________________________________________________________________________
TClass *TGeoAtt::Class()
{
   if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstance((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::GenerateInitInstance((const ::TGeoShape*)0x0)->GetImplFileName();
}

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

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

//______________________________________________________________________________
TClass *TGeoShape::Class()
{
   if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstance((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::GenerateInitInstance((const ::TGeoMatrix*)0x0)->GetImplFileName();
}

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

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

//______________________________________________________________________________
TClass *TGeoMatrix::Class()
{
   if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstance((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::GenerateInitInstance((const ::TGeoHMatrix*)0x0)->GetImplFileName();
}

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

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

//______________________________________________________________________________
TClass *TGeoHMatrix::Class()
{
   if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstance((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::GenerateInitInstance((const ::TGeoBoolNode*)0x0)->GetImplFileName();
}

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

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

//______________________________________________________________________________
TClass *TGeoBoolNode::Class()
{
   if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstance((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::GenerateInitInstance((const ::TGeoUnion*)0x0)->GetImplFileName();
}

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

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

//______________________________________________________________________________
TClass *TGeoUnion::Class()
{
   if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstance((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::GenerateInitInstance((const ::TGeoIntersection*)0x0)->GetImplFileName();
}

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

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

//______________________________________________________________________________
TClass *TGeoIntersection::Class()
{
   if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstance((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::GenerateInitInstance((const ::TGeoSubtraction*)0x0)->GetImplFileName();
}

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

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

//______________________________________________________________________________
TClass *TGeoSubtraction::Class()
{
   if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstance((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::GenerateInitInstance((const ::TGeoElementTable*)0x0)->GetImplFileName();
}

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

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

//______________________________________________________________________________
TClass *TGeoElementTable::Class()
{
   if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstance((const ::TGeoElementTable*)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::GenerateInitInstance((const ::TGeoElement*)0x0)->GetImplFileName();
}

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

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

//______________________________________________________________________________
TClass *TGeoElement::Class()
{
   if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstance((const ::TGeoElement*)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::GenerateInitInstance((const ::TGeoMaterial*)0x0)->GetImplFileName();
}

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

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

//______________________________________________________________________________
TClass *TGeoMaterial::Class()
{
   if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstance((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::GenerateInitInstance((const ::TGeoMixture*)0x0)->GetImplFileName();
}

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

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

//______________________________________________________________________________
TClass *TGeoMixture::Class()
{
   if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstance((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::GenerateInitInstance((const ::TGeoMedium*)0x0)->GetImplFileName();
}

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

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

//______________________________________________________________________________
TClass *TGeoMedium::Class()
{
   if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstance((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::GenerateInitInstance((const ::TGeoTranslation*)0x0)->GetImplFileName();
}

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

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

//______________________________________________________________________________
TClass *TGeoTranslation::Class()
{
   if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstance((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::GenerateInitInstance((const ::TGeoRotation*)0x0)->GetImplFileName();
}

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

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

//______________________________________________________________________________
TClass *TGeoRotation::Class()
{
   if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstance((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::GenerateInitInstance((const ::TGeoScale*)0x0)->GetImplFileName();
}

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

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

//______________________________________________________________________________
TClass *TGeoScale::Class()
{
   if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstance((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::GenerateInitInstance((const ::TGeoCombiTrans*)0x0)->GetImplFileName();
}

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

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

//______________________________________________________________________________
TClass *TGeoCombiTrans::Class()
{
   if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstance((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::GenerateInitInstance((const ::TGeoGenTrans*)0x0)->GetImplFileName();
}

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

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

//______________________________________________________________________________
TClass *TGeoGenTrans::Class()
{
   if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstance((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::GenerateInitInstance((const ::TGeoIdentity*)0x0)->GetImplFileName();
}

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

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

//______________________________________________________________________________
TClass *TGeoIdentity::Class()
{
   if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstance((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::GenerateInitInstance((const ::TGeoBBox*)0x0)->GetImplFileName();
}

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

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

//______________________________________________________________________________
TClass *TGeoBBox::Class()
{
   if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstance((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::GenerateInitInstance((const ::TGeoVolume*)0x0)->GetImplFileName();
}

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

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

//______________________________________________________________________________
TClass *TGeoVolume::Class()
{
   if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstance((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::GenerateInitInstance((const ::TGeoNode*)0x0)->GetImplFileName();
}

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

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

//______________________________________________________________________________
TClass *TGeoNode::Class()
{
   if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstance((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::GenerateInitInstance((const ::TGeoVoxelFinder*)0x0)->GetImplFileName();
}

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

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

//______________________________________________________________________________
TClass *TGeoVoxelFinder::Class()
{
   if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstance((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::GenerateInitInstance((const ::TGeoManager*)0x0)->GetImplFileName();
}

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

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

//______________________________________________________________________________
TClass *TGeoManager::Class()
{
   if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstance((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::GenerateInitInstance((const ::TGeoVolumeMulti*)0x0)->GetImplFileName();
}

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

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

//______________________________________________________________________________
TClass *TGeoVolumeMulti::Class()
{
   if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstance((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::GenerateInitInstance((const ::TGeoVolumeAssembly*)0x0)->GetImplFileName();
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

//______________________________________________________________________________
TClass *TGeoFullVoxels::Class()
{
   if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstance((const ::TGeoFullVoxels*)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::GenerateInitInstance((const ::TGeoNodeMatrix*)0x0)->GetImplFileName();
}

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

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

//______________________________________________________________________________
TClass *TGeoNodeMatrix::Class()
{
   if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstance((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::GenerateInitInstance((const ::TGeoNodeOffset*)0x0)->GetImplFileName();
}

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

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

//______________________________________________________________________________
TClass *TGeoNodeOffset::Class()
{
   if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstance((const ::TGeoNodeOffset*)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::GenerateInitInstance((const ::TGeoPara*)0x0)->GetImplFileName();
}

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

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

//______________________________________________________________________________
TClass *TGeoPara::Class()
{
   if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstance((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::GenerateInitInstance((const ::TGeoTube*)0x0)->GetImplFileName();
}

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

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

//______________________________________________________________________________
TClass *TGeoTube::Class()
{
   if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstance((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::GenerateInitInstance((const ::TGeoTubeSeg*)0x0)->GetImplFileName();
}

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

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

//______________________________________________________________________________
TClass *TGeoTubeSeg::Class()
{
   if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstance((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::GenerateInitInstance((const ::TGeoCtub*)0x0)->GetImplFileName();
}

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

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

//______________________________________________________________________________
TClass *TGeoCtub::Class()
{
   if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstance((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::GenerateInitInstance((const ::TGeoTorus*)0x0)->GetImplFileName();
}

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

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

//______________________________________________________________________________
TClass *TGeoTorus::Class()
{
   if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstance((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::GenerateInitInstance((const ::TGeoSphere*)0x0)->GetImplFileName();
}

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

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

//______________________________________________________________________________
TClass *TGeoSphere::Class()
{
   if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstance((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::GenerateInitInstance((const ::TGeoEltu*)0x0)->GetImplFileName();
}

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

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

//______________________________________________________________________________
TClass *TGeoEltu::Class()
{
   if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstance((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::GenerateInitInstance((const ::TGeoHype*)0x0)->GetImplFileName();
}

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

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

//______________________________________________________________________________
TClass *TGeoHype::Class()
{
   if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstance((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::GenerateInitInstance((const ::TGeoCone*)0x0)->GetImplFileName();
}

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

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

//______________________________________________________________________________
TClass *TGeoCone::Class()
{
   if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstance((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::GenerateInitInstance((const ::TGeoConeSeg*)0x0)->GetImplFileName();
}

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

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

//______________________________________________________________________________
TClass *TGeoConeSeg::Class()
{
   if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstance((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::GenerateInitInstance((const ::TGeoPcon*)0x0)->GetImplFileName();
}

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

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

//______________________________________________________________________________
TClass *TGeoPcon::Class()
{
   if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstance((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::GenerateInitInstance((const ::TGeoPgon*)0x0)->GetImplFileName();
}

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

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

//______________________________________________________________________________
TClass *TGeoPgon::Class()
{
   if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstance((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::GenerateInitInstance((const ::TGeoArb8*)0x0)->GetImplFileName();
}

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

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

//______________________________________________________________________________
TClass *TGeoArb8::Class()
{
   if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstance((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::GenerateInitInstance((const ::TGeoTrap*)0x0)->GetImplFileName();
}

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

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

//______________________________________________________________________________
TClass *TGeoTrap::Class()
{
   if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstance((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::GenerateInitInstance((const ::TGeoGtra*)0x0)->GetImplFileName();
}

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

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

//______________________________________________________________________________
TClass *TGeoGtra::Class()
{
   if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstance((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::GenerateInitInstance((const ::TGeoTrd1*)0x0)->GetImplFileName();
}

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

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

//______________________________________________________________________________
TClass *TGeoTrd1::Class()
{
   if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstance((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::GenerateInitInstance((const ::TGeoTrd2*)0x0)->GetImplFileName();
}

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

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

//______________________________________________________________________________
TClass *TGeoTrd2::Class()
{
   if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstance((const ::TGeoTrd2*)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::GenerateInitInstance((const ::TVirtualGeoTrack*)0x0)->GetImplFileName();
}

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

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

//______________________________________________________________________________
TClass *TVirtualGeoTrack::Class()
{
   if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstance((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::GenerateInitInstance((const ::TGeoPhysicalNode*)0x0)->GetImplFileName();
}

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

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

//______________________________________________________________________________
TClass *TGeoPhysicalNode::Class()
{
   if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstance((const ::TGeoPhysicalNode*)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::GenerateInitInstance((const ::TVirtualGeoPainter*)0x0)->GetImplFileName();
}

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

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

//______________________________________________________________________________
TClass *TVirtualGeoPainter::Class()
{
   if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstance((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::GenerateInitInstance((const ::TGeoCompositeShape*)0x0)->GetImplFileName();
}

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

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

//______________________________________________________________________________
TClass *TGeoCompositeShape::Class()
{
   if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstance((const ::TGeoCompositeShape*)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::GenerateInitInstance((const ::TGeoPolygon*)0x0)->GetImplFileName();
}

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

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

//______________________________________________________________________________
TClass *TGeoPolygon::Class()
{
   if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstance((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::GenerateInitInstance((const ::TGeoXtru*)0x0)->GetImplFileName();
}

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

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

//______________________________________________________________________________
TClass *TGeoXtru::Class()
{
   if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstance((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::GenerateInitInstance((const ::TGeoHelix*)0x0)->GetImplFileName();
}

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

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

//______________________________________________________________________________
TClass *TGeoHelix::Class()
{
   if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstance((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::GenerateInitInstance((const ::TGeoParaboloid*)0x0)->GetImplFileName();
}

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

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

//______________________________________________________________________________
TClass *TGeoParaboloid::Class()
{
   if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstance((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::GenerateInitInstance((const ::TGeoHalfSpace*)0x0)->GetImplFileName();
}

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

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

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

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

   if (R__b.IsReading()) {
      TGeoAtt::Class()->ReadBuffer(R__b, this);
   } else {
      TGeoAtt::Class()->WriteBuffer(R__b, this);
   }
}

//______________________________________________________________________________
void TGeoAtt::ShowMembers(TMemberInspector &R__insp, char *R__parent)
{
      // Inspect the data members of an object of class TGeoAtt.

      TClass *R__cl = ::TGeoAtt::IsA();
      Int_t R__ncp = strlen(R__parent);
      if (R__ncp || R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__parent, "fGeoAtt", &fGeoAtt);
}

namespace ROOT {
   // Return the actual TClass for the object argument
   static TClass *TGeoAtt_IsA(const void *obj) {
      return ((::TGeoAtt*)obj)->IsA();
   }
   // 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 size) {
      return new ::TGeoAtt[size];
   }
   // 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()) {
      TGeoBoolNode::Class()->ReadBuffer(R__b, this);
   } else {
      TGeoBoolNode::Class()->WriteBuffer(R__b, this);
   }
}

//______________________________________________________________________________
void TGeoBoolNode::ShowMembers(TMemberInspector &R__insp, char *R__parent)
{
      // Inspect the data members of an object of class TGeoBoolNode.

      TClass *R__cl = ::TGeoBoolNode::IsA();
      Int_t R__ncp = strlen(R__parent);
      if (R__ncp || R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__parent, "fSelected", &fSelected);
      R__insp.Inspect(R__cl, R__parent, "*fLeft", &fLeft);
      R__insp.Inspect(R__cl, R__parent, "*fRight", &fRight);
      R__insp.Inspect(R__cl, R__parent, "*fLeftMat", &fLeftMat);
      R__insp.Inspect(R__cl, R__parent, "*fRightMat", &fRightMat);
      TObject::ShowMembers(R__insp, R__parent);
}

namespace ROOT {
   // Return the actual TClass for the object argument
   static TClass *TGeoBoolNode_IsA(const void *obj) {
      return ((::TGeoBoolNode*)obj)->IsA();
   }
   // 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()) {
      TGeoUnion::Class()->ReadBuffer(R__b, this);
   } else {
      TGeoUnion::Class()->WriteBuffer(R__b, this);
   }
}

//______________________________________________________________________________
void TGeoUnion::ShowMembers(TMemberInspector &R__insp, char *R__parent)
{
      // Inspect the data members of an object of class TGeoUnion.

      TClass *R__cl = ::TGeoUnion::IsA();
      Int_t R__ncp = strlen(R__parent);
      if (R__ncp || R__cl || R__insp.IsA()) { }
      TGeoBoolNode::ShowMembers(R__insp, R__parent);
}

namespace ROOT {
   // Return the actual TClass for the object argument
   static TClass *TGeoUnion_IsA(const void *obj) {
      return ((::TGeoUnion*)obj)->IsA();
   }
   // Wrappers around operator new
   static void *new_TGeoUnion(void *p) {
      return  p ? new(p) ::TGeoUnion : new ::TGeoUnion;
   }
   static void *newArray_TGeoUnion(Long_t size) {
      return new ::TGeoUnion[size];
   }
   // 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()) {
      TGeoIntersection::Class()->ReadBuffer(R__b, this);
   } else {
      TGeoIntersection::Class()->WriteBuffer(R__b, this);
   }
}

//______________________________________________________________________________
void TGeoIntersection::ShowMembers(TMemberInspector &R__insp, char *R__parent)
{
      // Inspect the data members of an object of class TGeoIntersection.

      TClass *R__cl = ::TGeoIntersection::IsA();
      Int_t R__ncp = strlen(R__parent);
      if (R__ncp || R__cl || R__insp.IsA()) { }
      TGeoBoolNode::ShowMembers(R__insp, R__parent);
}

namespace ROOT {
   // Return the actual TClass for the object argument
   static TClass *TGeoIntersection_IsA(const void *obj) {
      return ((::TGeoIntersection*)obj)->IsA();
   }
   // Wrappers around operator new
   static void *new_TGeoIntersection(void *p) {
      return  p ? new(p) ::TGeoIntersection : new ::TGeoIntersection;
   }
   static void *newArray_TGeoIntersection(Long_t size) {
      return new ::TGeoIntersection[size];
   }
   // 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()) {
      TGeoSubtraction::Class()->ReadBuffer(R__b, this);
   } else {
      TGeoSubtraction::Class()->WriteBuffer(R__b, this);
   }
}

//______________________________________________________________________________
void TGeoSubtraction::ShowMembers(TMemberInspector &R__insp, char *R__parent)
{
      // Inspect the data members of an object of class TGeoSubtraction.

      TClass *R__cl = ::TGeoSubtraction::IsA();
      Int_t R__ncp = strlen(R__parent);
      if (R__ncp || R__cl || R__insp.IsA()) { }
      TGeoBoolNode::ShowMembers(R__insp, R__parent);
}

namespace ROOT {
   // Return the actual TClass for the object argument
   static TClass *TGeoSubtraction_IsA(const void *obj) {
      return ((::TGeoSubtraction*)obj)->IsA();
   }
   // Wrappers around operator new
   static void *new_TGeoSubtraction(void *p) {
      return  p ? new(p) ::TGeoSubtraction : new ::TGeoSubtraction;
   }
   static void *newArray_TGeoSubtraction(Long_t size) {
      return new ::TGeoSubtraction[size];
   }
   // 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()) {
      TGeoMedium::Class()->ReadBuffer(R__b, this);
   } else {
      TGeoMedium::Class()->WriteBuffer(R__b, this);
   }
}

//______________________________________________________________________________
void TGeoMedium::ShowMembers(TMemberInspector &R__insp, char *R__parent)
{
      // Inspect the data members of an object of class TGeoMedium.

      TClass *R__cl = ::TGeoMedium::IsA();
      Int_t R__ncp = strlen(R__parent);
      if (R__ncp || R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__parent, "fId", &fId);
      R__insp.Inspect(R__cl, R__parent, "fParams[20]", fParams);
      R__insp.Inspect(R__cl, R__parent, "*fMaterial", &fMaterial);
      TNamed::ShowMembers(R__insp, R__parent);
}

namespace ROOT {
   // Return the actual TClass for the object argument
   static TClass *TGeoMedium_IsA(const void *obj) {
      return ((::TGeoMedium*)obj)->IsA();
   }
   // Wrappers around operator new
   static void *new_TGeoMedium(void *p) {
      return  p ? new(p) ::TGeoMedium : new ::TGeoMedium;
   }
   static void *newArray_TGeoMedium(Long_t size) {
      return new ::TGeoMedium[size];
   }
   // 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()) {
      TGeoElement::Class()->ReadBuffer(R__b, this);
   } else {
      TGeoElement::Class()->WriteBuffer(R__b, this);
   }
}

//______________________________________________________________________________
void TGeoElement::ShowMembers(TMemberInspector &R__insp, char *R__parent)
{
      // Inspect the data members of an object of class TGeoElement.

      TClass *R__cl = ::TGeoElement::IsA();
      Int_t R__ncp = strlen(R__parent);
      if (R__ncp || R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__parent, "fZ", &fZ);
      R__insp.Inspect(R__cl, R__parent, "fA", &fA);
      TNamed::ShowMembers(R__insp, R__parent);
}

namespace ROOT {
   // Return the actual TClass for the object argument
   static TClass *TGeoElement_IsA(const void *obj) {
      return ((::TGeoElement*)obj)->IsA();
   }
   // Wrappers around operator new
   static void *new_TGeoElement(void *p) {
      return  p ? new(p) ::TGeoElement : new ::TGeoElement;
   }
   static void *newArray_TGeoElement(Long_t size) {
      return new ::TGeoElement[size];
   }
   // 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 TGeoElementTable::Streamer(TBuffer &R__b)
{
   // Stream an object of class TGeoElementTable.

   if (R__b.IsReading()) {
      TGeoElementTable::Class()->ReadBuffer(R__b, this);
   } else {
      TGeoElementTable::Class()->WriteBuffer(R__b, this);
   }
}

//______________________________________________________________________________
void TGeoElementTable::ShowMembers(TMemberInspector &R__insp, char *R__parent)
{
      // Inspect the data members of an object of class TGeoElementTable.

      TClass *R__cl = ::TGeoElementTable::IsA();
      Int_t R__ncp = strlen(R__parent);
      if (R__ncp || R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__parent, "fNelements", &fNelements);
      R__insp.Inspect(R__cl, R__parent, "*fList", &fList);
      TObject::ShowMembers(R__insp, R__parent);
}

namespace ROOT {
   // Return the actual TClass for the object argument
   static TClass *TGeoElementTable_IsA(const void *obj) {
      return ((::TGeoElementTable*)obj)->IsA();
   }
   // Wrappers around operator new
   static void *new_TGeoElementTable(void *p) {
      return  p ? new(p) ::TGeoElementTable : new ::TGeoElementTable;
   }
   static void *newArray_TGeoElementTable(Long_t size) {
      return new ::TGeoElementTable[size];
   }
   // 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()) {
      TGeoMaterial::Class()->ReadBuffer(R__b, this);
   } else {
      TGeoMaterial::Class()->WriteBuffer(R__b, this);
   }
}

//______________________________________________________________________________
void TGeoMaterial::ShowMembers(TMemberInspector &R__insp, char *R__parent)
{
      // Inspect the data members of an object of class TGeoMaterial.

      TClass *R__cl = ::TGeoMaterial::IsA();
      Int_t R__ncp = strlen(R__parent);
      if (R__ncp || R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__parent, "fIndex", &fIndex);
      R__insp.Inspect(R__cl, R__parent, "fA", &fA);
      R__insp.Inspect(R__cl, R__parent, "fZ", &fZ);
      R__insp.Inspect(R__cl, R__parent, "fDensity", &fDensity);
      R__insp.Inspect(R__cl, R__parent, "fRadLen", &fRadLen);
      R__insp.Inspect(R__cl, R__parent, "fIntLen", &fIntLen);
      R__insp.Inspect(R__cl, R__parent, "*fShader", &fShader);
      R__insp.Inspect(R__cl, R__parent, "*fCerenkov", &fCerenkov);
      TNamed::ShowMembers(R__insp, R__parent);
      TAttFill::ShowMembers(R__insp, R__parent);
}

namespace ROOT {
   // Return the actual TClass for the object argument
   static TClass *TGeoMaterial_IsA(const void *obj) {
      return ((::TGeoMaterial*)obj)->IsA();
   }
   // Wrappers around operator new
   static void *new_TGeoMaterial(void *p) {
      return  p ? new(p) ::TGeoMaterial : new ::TGeoMaterial;
   }
   static void *newArray_TGeoMaterial(Long_t size) {
      return new ::TGeoMaterial[size];
   }
   // 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()) {
      TGeoMixture::Class()->ReadBuffer(R__b, this);
   } else {
      TGeoMixture::Class()->WriteBuffer(R__b, this);
   }
}

//______________________________________________________________________________
void TGeoMixture::ShowMembers(TMemberInspector &R__insp, char *R__parent)
{
      // Inspect the data members of an object of class TGeoMixture.

      TClass *R__cl = ::TGeoMixture::IsA();
      Int_t R__ncp = strlen(R__parent);
      if (R__ncp || R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__parent, "fNelements", &fNelements);
      R__insp.Inspect(R__cl, R__parent, "*fZmixture", &fZmixture);
      R__insp.Inspect(R__cl, R__parent, "*fAmixture", &fAmixture);
      R__insp.Inspect(R__cl, R__parent, "*fWeights", &fWeights);
      TGeoMaterial::ShowMembers(R__insp, R__parent);
}

namespace ROOT {
   // Return the actual TClass for the object argument
   static TClass *TGeoMixture_IsA(const void *obj) {
      return ((::TGeoMixture*)obj)->IsA();
   }
   // Wrappers around operator new
   static void *new_TGeoMixture(void *p) {
      return  p ? new(p) ::TGeoMixture : new ::TGeoMixture;
   }
   static void *newArray_TGeoMixture(Long_t size) {
      return new ::TGeoMixture[size];
   }
   // 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()) {
      TGeoMatrix::Class()->ReadBuffer(R__b, this);
   } else {
      TGeoMatrix::Class()->WriteBuffer(R__b, this);
   }
}

//______________________________________________________________________________
void TGeoMatrix::ShowMembers(TMemberInspector &R__insp, char *R__parent)
{
      // Inspect the data members of an object of class TGeoMatrix.

      TClass *R__cl = ::TGeoMatrix::IsA();
      Int_t R__ncp = strlen(R__parent);
      if (R__ncp || R__cl || R__insp.IsA()) { }
      TNamed::ShowMembers(R__insp, R__parent);
}

namespace ROOT {
   // Return the actual TClass for the object argument
   static TClass *TGeoMatrix_IsA(const void *obj) {
      return ((::TGeoMatrix*)obj)->IsA();
   }
   // 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()) {
      TGeoHMatrix::Class()->ReadBuffer(R__b, this);
   } else {
      TGeoHMatrix::Class()->WriteBuffer(R__b, this);
   }
}

//______________________________________________________________________________
void TGeoHMatrix::ShowMembers(TMemberInspector &R__insp, char *R__parent)
{
      // Inspect the data members of an object of class TGeoHMatrix.

      TClass *R__cl = ::TGeoHMatrix::IsA();
      Int_t R__ncp = strlen(R__parent);
      if (R__ncp || R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__parent, "fTranslation[3]", fTranslation);
      R__insp.Inspect(R__cl, R__parent, "fRotationMatrix[9]", fRotationMatrix);
      R__insp.Inspect(R__cl, R__parent, "fScale[3]", fScale);
      TGeoMatrix::ShowMembers(R__insp, R__parent);
}

namespace ROOT {
   // Return the actual TClass for the object argument
   static TClass *TGeoHMatrix_IsA(const void *obj) {
      return ((::TGeoHMatrix*)obj)->IsA();
   }
   // Wrappers around operator new
   static void *new_TGeoHMatrix(void *p) {
      return  p ? new(p) ::TGeoHMatrix : new ::TGeoHMatrix;
   }
   static void *newArray_TGeoHMatrix(Long_t size) {
      return new ::TGeoHMatrix[size];
   }
   // 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()) {
      TGeoTranslation::Class()->ReadBuffer(R__b, this);
   } else {
      TGeoTranslation::Class()->WriteBuffer(R__b, this);
   }
}

//______________________________________________________________________________
void TGeoTranslation::ShowMembers(TMemberInspector &R__insp, char *R__parent)
{
      // Inspect the data members of an object of class TGeoTranslation.

      TClass *R__cl = ::TGeoTranslation::IsA();
      Int_t R__ncp = strlen(R__parent);
      if (R__ncp || R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__parent, "fTranslation[3]", fTranslation);
      TGeoMatrix::ShowMembers(R__insp, R__parent);
}

namespace ROOT {
   // Return the actual TClass for the object argument
   static TClass *TGeoTranslation_IsA(const void *obj) {
      return ((::TGeoTranslation*)obj)->IsA();
   }
   // Wrappers around operator new
   static void *new_TGeoTranslation(void *p) {
      return  p ? new(p) ::TGeoTranslation : new ::TGeoTranslation;
   }
   static void *newArray_TGeoTranslation(Long_t size) {
      return new ::TGeoTranslation[size];
   }
   // 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()) {
      TGeoRotation::Class()->ReadBuffer(R__b, this);
   } else {
      TGeoRotation::Class()->WriteBuffer(R__b, this);
   }
}

//______________________________________________________________________________
void TGeoRotation::ShowMembers(TMemberInspector &R__insp, char *R__parent)
{
      // Inspect the data members of an object of class TGeoRotation.

      TClass *R__cl = ::TGeoRotation::IsA();
      Int_t R__ncp = strlen(R__parent);
      if (R__ncp || R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__parent, "fRotationMatrix[9]", fRotationMatrix);
      TGeoMatrix::ShowMembers(R__insp, R__parent);
}

namespace ROOT {
   // Return the actual TClass for the object argument
   static TClass *TGeoRotation_IsA(const void *obj) {
      return ((::TGeoRotation*)obj)->IsA();
   }
   // Wrappers around operator new
   static void *new_TGeoRotation(void *p) {
      return  p ? new(p) ::TGeoRotation : new ::TGeoRotation;
   }
   static void *newArray_TGeoRotation(Long_t size) {
      return new ::TGeoRotation[size];
   }
   // 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()) {
      TGeoCombiTrans::Class()->ReadBuffer(R__b, this);
   } else {
      TGeoCombiTrans::Class()->WriteBuffer(R__b, this);
   }
}

//______________________________________________________________________________
void TGeoCombiTrans::ShowMembers(TMemberInspector &R__insp, char *R__parent)
{
      // Inspect the data members of an object of class TGeoCombiTrans.

      TClass *R__cl = ::TGeoCombiTrans::IsA();
      Int_t R__ncp = strlen(R__parent);
      if (R__ncp || R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__parent, "fTranslation[3]", fTranslation);
      R__insp.Inspect(R__cl, R__parent, "*fRotation", &fRotation);
      TGeoMatrix::ShowMembers(R__insp, R__parent);
}

namespace ROOT {
   // Return the actual TClass for the object argument
   static TClass *TGeoCombiTrans_IsA(const void *obj) {
      return ((::TGeoCombiTrans*)obj)->IsA();
   }
   // Wrappers around operator new
   static void *new_TGeoCombiTrans(void *p) {
      return  p ? new(p) ::TGeoCombiTrans : new ::TGeoCombiTrans;
   }
   static void *newArray_TGeoCombiTrans(Long_t size) {
      return new ::TGeoCombiTrans[size];
   }
   // 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()) {
      TGeoGenTrans::Class()->ReadBuffer(R__b, this);
   } else {
      TGeoGenTrans::Class()->WriteBuffer(R__b, this);
   }
}

//______________________________________________________________________________
void TGeoGenTrans::ShowMembers(TMemberInspector &R__insp, char *R__parent)
{
      // Inspect the data members of an object of class TGeoGenTrans.

      TClass *R__cl = ::TGeoGenTrans::IsA();
      Int_t R__ncp = strlen(R__parent);
      if (R__ncp || R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__parent, "fScale[3]", fScale);
      TGeoCombiTrans::ShowMembers(R__insp, R__parent);
}

namespace ROOT {
   // Return the actual TClass for the object argument
   static TClass *TGeoGenTrans_IsA(const void *obj) {
      return ((::TGeoGenTrans*)obj)->IsA();
   }
   // Wrappers around operator new
   static void *new_TGeoGenTrans(void *p) {
      return  p ? new(p) ::TGeoGenTrans : new ::TGeoGenTrans;
   }
   static void *newArray_TGeoGenTrans(Long_t size) {
      return new ::TGeoGenTrans[size];
   }
   // 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()) {
      TGeoScale::Class()->ReadBuffer(R__b, this);
   } else {
      TGeoScale::Class()->WriteBuffer(R__b, this);
   }
}

//______________________________________________________________________________
void TGeoScale::ShowMembers(TMemberInspector &R__insp, char *R__parent)
{
      // Inspect the data members of an object of class TGeoScale.

      TClass *R__cl = ::TGeoScale::IsA();
      Int_t R__ncp = strlen(R__parent);
      if (R__ncp || R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__parent, "fScale[3]", fScale);
      TGeoMatrix::ShowMembers(R__insp, R__parent);
}

namespace ROOT {
   // Return the actual TClass for the object argument
   static TClass *TGeoScale_IsA(const void *obj) {
      return ((::TGeoScale*)obj)->IsA();
   }
   // Wrappers around operator new
   static void *new_TGeoScale(void *p) {
      return  p ? new(p) ::TGeoScale : new ::TGeoScale;
   }
   static void *newArray_TGeoScale(Long_t size) {
      return new ::TGeoScale[size];
   }
   // 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()) {
      TGeoIdentity::Class()->ReadBuffer(R__b, this);
   } else {
      TGeoIdentity::Class()->WriteBuffer(R__b, this);
   }
}

//______________________________________________________________________________
void TGeoIdentity::ShowMembers(TMemberInspector &R__insp, char *R__parent)
{
      // Inspect the data members of an object of class TGeoIdentity.

      TClass *R__cl = ::TGeoIdentity::IsA();
      Int_t R__ncp = strlen(R__parent);
      if (R__ncp || R__cl || R__insp.IsA()) { }
      TGeoMatrix::ShowMembers(R__insp, R__parent);
}

namespace ROOT {
   // Return the actual TClass for the object argument
   static TClass *TGeoIdentity_IsA(const void *obj) {
      return ((::TGeoIdentity*)obj)->IsA();
   }
   // Wrappers around operator new
   static void *new_TGeoIdentity(void *p) {
      return  p ? new(p) ::TGeoIdentity : new ::TGeoIdentity;
   }
   static void *newArray_TGeoIdentity(Long_t size) {
      return new ::TGeoIdentity[size];
   }
   // 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::Streamer(TBuffer &R__b)
{
   // Stream an object of class TGeoVoxelFinder.

   if (R__b.IsReading()) {
      TGeoVoxelFinder::Class()->ReadBuffer(R__b, this);
   } else {
      TGeoVoxelFinder::Class()->WriteBuffer(R__b, this);
   }
}

//______________________________________________________________________________
void TGeoVoxelFinder::ShowMembers(TMemberInspector &R__insp, char *R__parent)
{
      // Inspect the data members of an object of class TGeoVoxelFinder.

      TClass *R__cl = ::TGeoVoxelFinder::IsA();
      Int_t R__ncp = strlen(R__parent);
      if (R__ncp || R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__parent, "*fVolume", &fVolume);
      R__insp.Inspect(R__cl, R__parent, "fNcandidates", &fNcandidates);
      R__insp.Inspect(R__cl, R__parent, "fCurrentVoxel", &fCurrentVoxel);
      R__insp.Inspect(R__cl, R__parent, "fIbx", &fIbx);
      R__insp.Inspect(R__cl, R__parent, "fIby", &fIby);
      R__insp.Inspect(R__cl, R__parent, "fIbz", &fIbz);
      R__insp.Inspect(R__cl, R__parent, "fNboxes", &fNboxes);
      R__insp.Inspect(R__cl, R__parent, "fNox", &fNox);
      R__insp.Inspect(R__cl, R__parent, "fNoy", &fNoy);
      R__insp.Inspect(R__cl, R__parent, "fNoz", &fNoz);
      R__insp.Inspect(R__cl, R__parent, "fNex", &fNex);
      R__insp.Inspect(R__cl, R__parent, "fNey", &fNey);
      R__insp.Inspect(R__cl, R__parent, "fNez", &fNez);
      R__insp.Inspect(R__cl, R__parent, "fNx", &fNx);
      R__insp.Inspect(R__cl, R__parent, "fNy", &fNy);
      R__insp.Inspect(R__cl, R__parent, "fNz", &fNz);
      R__insp.Inspect(R__cl, R__parent, "fPriority[3]", fPriority);
      R__insp.Inspect(R__cl, R__parent, "fSlices[3]", fSlices);
      R__insp.Inspect(R__cl, R__parent, "fInc[3]", fInc);
      R__insp.Inspect(R__cl, R__parent, "fInvdir[3]", fInvdir);
      R__insp.Inspect(R__cl, R__parent, "fLimits[3]", fLimits);
      R__insp.Inspect(R__cl, R__parent, "*fBoxes", &fBoxes);
      R__insp.Inspect(R__cl, R__parent, "*fXb", &fXb);
      R__insp.Inspect(R__cl, R__parent, "*fYb", &fYb);
      R__insp.Inspect(R__cl, R__parent, "*fZb", &fZb);
      R__insp.Inspect(R__cl, R__parent, "*fOBx", &fOBx);
      R__insp.Inspect(R__cl, R__parent, "*fOBy", &fOBy);
      R__insp.Inspect(R__cl, R__parent, "*fOBz", &fOBz);
      R__insp.Inspect(R__cl, R__parent, "*fOEx", &fOEx);
      R__insp.Inspect(R__cl, R__parent, "*fOEy", &fOEy);
      R__insp.Inspect(R__cl, R__parent, "*fOEz", &fOEz);
      R__insp.Inspect(R__cl, R__parent, "*fIndX", &fIndX);
      R__insp.Inspect(R__cl, R__parent, "*fIndY", &fIndY);
      R__insp.Inspect(R__cl, R__parent, "*fIndZ", &fIndZ);
      R__insp.Inspect(R__cl, R__parent, "*fExtraX", &fExtraX);
      R__insp.Inspect(R__cl, R__parent, "*fExtraY", &fExtraY);
      R__insp.Inspect(R__cl, R__parent, "*fExtraZ", &fExtraZ);
      R__insp.Inspect(R__cl, R__parent, "*fCheckList", &fCheckList);
      TObject::ShowMembers(R__insp, R__parent);
}

namespace ROOT {
   // Return the actual TClass for the object argument
   static TClass *TGeoVoxelFinder_IsA(const void *obj) {
      return ((::TGeoVoxelFinder*)obj)->IsA();
   }
   // Wrappers around operator new
   static void *new_TGeoVoxelFinder(void *p) {
      return  p ? new(p) ::TGeoVoxelFinder : new ::TGeoVoxelFinder;
   }
   static void *newArray_TGeoVoxelFinder(Long_t size) {
      return new ::TGeoVoxelFinder[size];
   }
   // 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();
   }
} // end of namespace ROOT for class ::TGeoVoxelFinder

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

   if (R__b.IsReading()) {
      TGeoCylVoxels::Class()->ReadBuffer(R__b, this);
   } else {
      TGeoCylVoxels::Class()->WriteBuffer(R__b, this);
   }
}

//______________________________________________________________________________
void TGeoCylVoxels::ShowMembers(TMemberInspector &R__insp, char *R__parent)
{
      // Inspect the data members of an object of class TGeoCylVoxels.

      TClass *R__cl = ::TGeoCylVoxels::IsA();
      Int_t R__ncp = strlen(R__parent);
      if (R__ncp || R__cl || R__insp.IsA()) { }
      TGeoVoxelFinder::ShowMembers(R__insp, R__parent);
}

namespace ROOT {
   // Return the actual TClass for the object argument
   static TClass *TGeoCylVoxels_IsA(const void *obj) {
      return ((::TGeoCylVoxels*)obj)->IsA();
   }
   // Wrappers around operator new
   static void *new_TGeoCylVoxels(void *p) {
      return  p ? new(p) ::TGeoCylVoxels : new ::TGeoCylVoxels;
   }
   static void *newArray_TGeoCylVoxels(Long_t size) {
      return new ::TGeoCylVoxels[size];
   }
   // Wrapper around operator delete
   static void delete_TGeoCylVoxels(void *p) {
      delete ((::TGeoCylVoxels*)p);
   }
   static void deleteArray_TGeoCylVoxels(void *p) {
      delete [] ((::TGeoCylVoxels*)p);
   }
   static void destruct_TGeoCylVoxels(void *p) {
      typedef ::TGeoCylVoxels current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TGeoCylVoxels

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

   if (R__b.IsReading()) {
      TGeoFullVoxels::Class()->ReadBuffer(R__b, this);
   } else {
      TGeoFullVoxels::Class()->WriteBuffer(R__b, this);
   }
}

//______________________________________________________________________________
void TGeoFullVoxels::ShowMembers(TMemberInspector &R__insp, char *R__parent)
{
      // Inspect the data members of an object of class TGeoFullVoxels.

      TClass *R__cl = ::TGeoFullVoxels::IsA();
      Int_t R__ncp = strlen(R__parent);
      if (R__ncp || R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__parent, "fNvoxels", &fNvoxels);
      R__insp.Inspect(R__cl, R__parent, "fNvx", &fNvx);
      R__insp.Inspect(R__cl, R__parent, "fNvy", &fNvy);
      R__insp.Inspect(R__cl, R__parent, "fNvz", &fNvz);
      R__insp.Inspect(R__cl, R__parent, "*fVox", &fVox);
      TGeoVoxelFinder::ShowMembers(R__insp, R__parent);
}

namespace ROOT {
   // Return the actual TClass for the object argument
   static TClass *TGeoFullVoxels_IsA(const void *obj) {
      return ((::TGeoFullVoxels*)obj)->IsA();
   }
   // Wrappers around operator new
   static void *new_TGeoFullVoxels(void *p) {
      return  p ? new(p) ::TGeoFullVoxels : new ::TGeoFullVoxels;
   }
   static void *newArray_TGeoFullVoxels(Long_t size) {
      return new ::TGeoFullVoxels[size];
   }
   // Wrapper around operator delete
   static void delete_TGeoFullVoxels(void *p) {
      delete ((::TGeoFullVoxels*)p);
   }
   static void deleteArray_TGeoFullVoxels(void *p) {
      delete [] ((::TGeoFullVoxels*)p);
   }
   static void destruct_TGeoFullVoxels(void *p) {
      typedef ::TGeoFullVoxels current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TGeoFullVoxels

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

   if (R__b.IsReading()) {
      TGeoShape::Class()->ReadBuffer(R__b, this);
   } else {
      TGeoShape::Class()->WriteBuffer(R__b, this);
   }
}

//______________________________________________________________________________
void TGeoShape::ShowMembers(TMemberInspector &R__insp, char *R__parent)
{
      // Inspect the data members of an object of class TGeoShape.

      TClass *R__cl = ::TGeoShape::IsA();
      Int_t R__ncp = strlen(R__parent);
      if (R__ncp || R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__parent, "fShapeId", &fShapeId);
      R__insp.Inspect(R__cl, R__parent, "fShapeBits", &fShapeBits);
      TNamed::ShowMembers(R__insp, R__parent);
}

namespace ROOT {
   // Return the actual TClass for the object argument
   static TClass *TGeoShape_IsA(const void *obj) {
      return ((::TGeoShape*)obj)->IsA();
   }
   // 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()) {
      TGeoHelix::Class()->ReadBuffer(R__b, this);
   } else {
      TGeoHelix::Class()->WriteBuffer(R__b, this);
   }
}

//______________________________________________________________________________
void TGeoHelix::ShowMembers(TMemberInspector &R__insp, char *R__parent)
{
      // Inspect the data members of an object of class TGeoHelix.

      TClass *R__cl = ::TGeoHelix::IsA();
      Int_t R__ncp = strlen(R__parent);
      if (R__ncp || R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__parent, "fC", &fC);
      R__insp.Inspect(R__cl, R__parent, "fS", &fS);
      R__insp.Inspect(R__cl, R__parent, "fStep", &fStep);
      R__insp.Inspect(R__cl, R__parent, "fPhi", &fPhi);
      R__insp.Inspect(R__cl, R__parent, "fPointInit[3]", fPointInit);
      R__insp.Inspect(R__cl, R__parent, "fDirInit[3]", fDirInit);
      R__insp.Inspect(R__cl, R__parent, "fPoint[3]", fPoint);
      R__insp.Inspect(R__cl, R__parent, "fDir[3]", fDir);
      R__insp.Inspect(R__cl, R__parent, "fB[3]", fB);
      R__insp.Inspect(R__cl, R__parent, "fQ", &fQ);
      R__insp.Inspect(R__cl, R__parent, "*fMatrix", &fMatrix);
      TObject::ShowMembers(R__insp, R__parent);
}

namespace ROOT {
   // Return the actual TClass for the object argument
   static TClass *TGeoHelix_IsA(const void *obj) {
      return ((::TGeoHelix*)obj)->IsA();
   }
   // Wrappers around operator new
   static void *new_TGeoHelix(void *p) {
      return  p ? new(p) ::TGeoHelix : new ::TGeoHelix;
   }
   static void *newArray_TGeoHelix(Long_t size) {
      return new ::TGeoHelix[size];
   }
   // 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()) {
      TGeoHalfSpace::Class()->ReadBuffer(R__b, this);
   } else {
      TGeoHalfSpace::Class()->WriteBuffer(R__b, this);
   }
}

//______________________________________________________________________________
void TGeoHalfSpace::ShowMembers(TMemberInspector &R__insp, char *R__parent)
{
      // Inspect the data members of an object of class TGeoHalfSpace.

      TClass *R__cl = ::TGeoHalfSpace::IsA();
      Int_t R__ncp = strlen(R__parent);
      if (R__ncp || R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__parent, "fP[3]", fP);
      R__insp.Inspect(R__cl, R__parent, "fN[3]", fN);
      TGeoBBox::ShowMembers(R__insp, R__parent);
}

namespace ROOT {
   // Return the actual TClass for the object argument
   static TClass *TGeoHalfSpace_IsA(const void *obj) {
      return ((::TGeoHalfSpace*)obj)->IsA();
   }
   // Wrappers around operator new
   static void *new_TGeoHalfSpace(void *p) {
      return  p ? new(p) ::TGeoHalfSpace : new ::TGeoHalfSpace;
   }
   static void *newArray_TGeoHalfSpace(Long_t size) {
      return new ::TGeoHalfSpace[size];
   }
   // 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()) {
      TGeoBBox::Class()->ReadBuffer(R__b, this);
   } else {
      TGeoBBox::Class()->WriteBuffer(R__b, this);
   }
}

//______________________________________________________________________________
void TGeoBBox::ShowMembers(TMemberInspector &R__insp, char *R__parent)
{
      // Inspect the data members of an object of class TGeoBBox.

      TClass *R__cl = ::TGeoBBox::IsA();
      Int_t R__ncp = strlen(R__parent);
      if (R__ncp || R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__parent, "fDX", &fDX);
      R__insp.Inspect(R__cl, R__parent, "fDY", &fDY);
      R__insp.Inspect(R__cl, R__parent, "fDZ", &fDZ);
      R__insp.Inspect(R__cl, R__parent, "fOrigin[3]", fOrigin);
      TGeoShape::ShowMembers(R__insp, R__parent);
}

namespace ROOT {
   // Return the actual TClass for the object argument
   static TClass *TGeoBBox_IsA(const void *obj) {
      return ((::TGeoBBox*)obj)->IsA();
   }
   // Wrappers around operator new
   static void *new_TGeoBBox(void *p) {
      return  p ? new(p) ::TGeoBBox : new ::TGeoBBox;
   }
   static void *newArray_TGeoBBox(Long_t size) {
      return new ::TGeoBBox[size];
   }
   // 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()) {
      TGeoPara::Class()->ReadBuffer(R__b, this);
   } else {
      TGeoPara::Class()->WriteBuffer(R__b, this);
   }
}

//______________________________________________________________________________
void TGeoPara::ShowMembers(TMemberInspector &R__insp, char *R__parent)
{
      // Inspect the data members of an object of class TGeoPara.

      TClass *R__cl = ::TGeoPara::IsA();
      Int_t R__ncp = strlen(R__parent);
      if (R__ncp || R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__parent, "fX", &fX);
      R__insp.Inspect(R__cl, R__parent, "fY", &fY);
      R__insp.Inspect(R__cl, R__parent, "fZ", &fZ);
      R__insp.Inspect(R__cl, R__parent, "fAlpha", &fAlpha);
      R__insp.Inspect(R__cl, R__parent, "fTheta", &fTheta);
      R__insp.Inspect(R__cl, R__parent, "fPhi", &fPhi);
      R__insp.Inspect(R__cl, R__parent, "fTxy", &fTxy);
      R__insp.Inspect(R__cl, R__parent, "fTxz", &fTxz);
      R__insp.Inspect(R__cl, R__parent, "fTyz", &fTyz);
      TGeoBBox::ShowMembers(R__insp, R__parent);
}

namespace ROOT {
   // Return the actual TClass for the object argument
   static TClass *TGeoPara_IsA(const void *obj) {
      return ((::TGeoPara*)obj)->IsA();
   }
   // Wrappers around operator new
   static void *new_TGeoPara(void *p) {
      return  p ? new(p) ::TGeoPara : new ::TGeoPara;
   }
   static void *newArray_TGeoPara(Long_t size) {
      return new ::TGeoPara[size];
   }
   // 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()) {
      TGeoSphere::Class()->ReadBuffer(R__b, this);
   } else {
      TGeoSphere::Class()->WriteBuffer(R__b, this);
   }
}

//______________________________________________________________________________
void TGeoSphere::ShowMembers(TMemberInspector &R__insp, char *R__parent)
{
      // Inspect the data members of an object of class TGeoSphere.

      TClass *R__cl = ::TGeoSphere::IsA();
      Int_t R__ncp = strlen(R__parent);
      if (R__ncp || R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__parent, "fNz", &fNz);
      R__insp.Inspect(R__cl, R__parent, "fNseg", &fNseg);
      R__insp.Inspect(R__cl, R__parent, "fRmin", &fRmin);
      R__insp.Inspect(R__cl, R__parent, "fRmax", &fRmax);
      R__insp.Inspect(R__cl, R__parent, "fTheta1", &fTheta1);
      R__insp.Inspect(R__cl, R__parent, "fTheta2", &fTheta2);
      R__insp.Inspect(R__cl, R__parent, "fPhi1", &fPhi1);
      R__insp.Inspect(R__cl, R__parent, "fPhi2", &fPhi2);
      TGeoBBox::ShowMembers(R__insp, R__parent);
}

namespace ROOT {
   // Return the actual TClass for the object argument
   static TClass *TGeoSphere_IsA(const void *obj) {
      return ((::TGeoSphere*)obj)->IsA();
   }
   // Wrappers around operator new
   static void *new_TGeoSphere(void *p) {
      return  p ? new(p) ::TGeoSphere : new ::TGeoSphere;
   }
   static void *newArray_TGeoSphere(Long_t size) {
      return new ::TGeoSphere[size];
   }
   // 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()) {
      TGeoTube::Class()->ReadBuffer(R__b, this);
   } else {
      TGeoTube::Class()->WriteBuffer(R__b, this);
   }
}

//______________________________________________________________________________
void TGeoTube::ShowMembers(TMemberInspector &R__insp, char *R__parent)
{
      // Inspect the data members of an object of class TGeoTube.

      TClass *R__cl = ::TGeoTube::IsA();
      Int_t R__ncp = strlen(R__parent);
      if (R__ncp || R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__parent, "fRmin", &fRmin);
      R__insp.Inspect(R__cl, R__parent, "fRmax", &fRmax);
      R__insp.Inspect(R__cl, R__parent, "fDz", &fDz);
      TGeoBBox::ShowMembers(R__insp, R__parent);
}

namespace ROOT {
   // Return the actual TClass for the object argument
   static TClass *TGeoTube_IsA(const void *obj) {
      return ((::TGeoTube*)obj)->IsA();
   }
   // Wrappers around operator new
   static void *new_TGeoTube(void *p) {
      return  p ? new(p) ::TGeoTube : new ::TGeoTube;
   }
   static void *newArray_TGeoTube(Long_t size) {
      return new ::TGeoTube[size];
   }
   // 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()) {
      TGeoTorus::Class()->ReadBuffer(R__b, this);
   } else {
      TGeoTorus::Class()->WriteBuffer(R__b, this);
   }
}

//______________________________________________________________________________
void TGeoTorus::ShowMembers(TMemberInspector &R__insp, char *R__parent)
{
      // Inspect the data members of an object of class TGeoTorus.

      TClass *R__cl = ::TGeoTorus::IsA();
      Int_t R__ncp = strlen(R__parent);
      if (R__ncp || R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__parent, "fR", &fR);
      R__insp.Inspect(R__cl, R__parent, "fRmin", &fRmin);
      R__insp.Inspect(R__cl, R__parent, "fRmax", &fRmax);
      R__insp.Inspect(R__cl, R__parent, "fPhi1", &fPhi1);
      R__insp.Inspect(R__cl, R__parent, "fDphi", &fDphi);
      TGeoBBox::ShowMembers(R__insp, R__parent);
}

namespace ROOT {
   // Return the actual TClass for the object argument
   static TClass *TGeoTorus_IsA(const void *obj) {
      return ((::TGeoTorus*)obj)->IsA();
   }
   // Wrappers around operator new
   static void *new_TGeoTorus(void *p) {
      return  p ? new(p) ::TGeoTorus : new ::TGeoTorus;
   }
   static void *newArray_TGeoTorus(Long_t size) {
      return new ::TGeoTorus[size];
   }
   // 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()) {
      TGeoTubeSeg::Class()->ReadBuffer(R__b, this);
   } else {
      TGeoTubeSeg::Class()->WriteBuffer(R__b, this);
   }
}

//______________________________________________________________________________
void TGeoTubeSeg::ShowMembers(TMemberInspector &R__insp, char *R__parent)
{
      // Inspect the data members of an object of class TGeoTubeSeg.

      TClass *R__cl = ::TGeoTubeSeg::IsA();
      Int_t R__ncp = strlen(R__parent);
      if (R__ncp || R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__parent, "fPhi1", &fPhi1);
      R__insp.Inspect(R__cl, R__parent, "fPhi2", &fPhi2);
      TGeoTube::ShowMembers(R__insp, R__parent);
}

namespace ROOT {
   // Return the actual TClass for the object argument
   static TClass *TGeoTubeSeg_IsA(const void *obj) {
      return ((::TGeoTubeSeg*)obj)->IsA();
   }
   // Wrappers around operator new
   static void *new_TGeoTubeSeg(void *p) {
      return  p ? new(p) ::TGeoTubeSeg : new ::TGeoTubeSeg;
   }
   static void *newArray_TGeoTubeSeg(Long_t size) {
      return new ::TGeoTubeSeg[size];
   }
   // 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()) {
      TGeoCtub::Class()->ReadBuffer(R__b, this);
   } else {
      TGeoCtub::Class()->WriteBuffer(R__b, this);
   }
}

//______________________________________________________________________________
void TGeoCtub::ShowMembers(TMemberInspector &R__insp, char *R__parent)
{
      // Inspect the data members of an object of class TGeoCtub.

      TClass *R__cl = ::TGeoCtub::IsA();
      Int_t R__ncp = strlen(R__parent);
      if (R__ncp || R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__parent, "fNlow[3]", fNlow);
      R__insp.Inspect(R__cl, R__parent, "fNhigh[3]", fNhigh);
      TGeoTubeSeg::ShowMembers(R__insp, R__parent);
}

namespace ROOT {
   // Return the actual TClass for the object argument
   static TClass *TGeoCtub_IsA(const void *obj) {
      return ((::TGeoCtub*)obj)->IsA();
   }
   // Wrappers around operator new
   static void *new_TGeoCtub(void *p) {
      return  p ? new(p) ::TGeoCtub : new ::TGeoCtub;
   }
   static void *newArray_TGeoCtub(Long_t size) {
      return new ::TGeoCtub[size];
   }
   // 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()) {
      TGeoEltu::Class()->ReadBuffer(R__b, this);
   } else {
      TGeoEltu::Class()->WriteBuffer(R__b, this);
   }
}

//______________________________________________________________________________
void TGeoEltu::ShowMembers(TMemberInspector &R__insp, char *R__parent)
{
      // Inspect the data members of an object of class TGeoEltu.

      TClass *R__cl = ::TGeoEltu::IsA();
      Int_t R__ncp = strlen(R__parent);
      if (R__ncp || R__cl || R__insp.IsA()) { }
      TGeoTube::ShowMembers(R__insp, R__parent);
}

namespace ROOT {
   // Return the actual TClass for the object argument
   static TClass *TGeoEltu_IsA(const void *obj) {
      return ((::TGeoEltu*)obj)->IsA();
   }
   // Wrappers around operator new
   static void *new_TGeoEltu(void *p) {
      return  p ? new(p) ::TGeoEltu : new ::TGeoEltu;
   }
   static void *newArray_TGeoEltu(Long_t size) {
      return new ::TGeoEltu[size];
   }
   // 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()) {
      TGeoHype::Class()->ReadBuffer(R__b, this);
   } else {
      TGeoHype::Class()->WriteBuffer(R__b, this);
   }
}

//______________________________________________________________________________
void TGeoHype::ShowMembers(TMemberInspector &R__insp, char *R__parent)
{
      // Inspect the data members of an object of class TGeoHype.

      TClass *R__cl = ::TGeoHype::IsA();
      Int_t R__ncp = strlen(R__parent);
      if (R__ncp || R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__parent, "fStIn", &fStIn);
      R__insp.Inspect(R__cl, R__parent, "fStOut", &fStOut);
      R__insp.Inspect(R__cl, R__parent, "fTin", &fTin);
      R__insp.Inspect(R__cl, R__parent, "fTout", &fTout);
      R__insp.Inspect(R__cl, R__parent, "fTinsq", &fTinsq);
      R__insp.Inspect(R__cl, R__parent, "fToutsq", &fToutsq);
      TGeoTube::ShowMembers(R__insp, R__parent);
}

namespace ROOT {
   // Return the actual TClass for the object argument
   static TClass *TGeoHype_IsA(const void *obj) {
      return ((::TGeoHype*)obj)->IsA();
   }
   // Wrappers around operator new
   static void *new_TGeoHype(void *p) {
      return  p ? new(p) ::TGeoHype : new ::TGeoHype;
   }
   static void *newArray_TGeoHype(Long_t size) {
      return new ::TGeoHype[size];
   }
   // 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()) {
      TGeoCone::Class()->ReadBuffer(R__b, this);
   } else {
      TGeoCone::Class()->WriteBuffer(R__b, this);
   }
}

//______________________________________________________________________________
void TGeoCone::ShowMembers(TMemberInspector &R__insp, char *R__parent)
{
      // Inspect the data members of an object of class TGeoCone.

      TClass *R__cl = ::TGeoCone::IsA();
      Int_t R__ncp = strlen(R__parent);
      if (R__ncp || R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__parent, "fDz", &fDz);
      R__insp.Inspect(R__cl, R__parent, "fRmin1", &fRmin1);
      R__insp.Inspect(R__cl, R__parent, "fRmax1", &fRmax1);
      R__insp.Inspect(R__cl, R__parent, "fRmin2", &fRmin2);
      R__insp.Inspect(R__cl, R__parent, "fRmax2", &fRmax2);
      TGeoBBox::ShowMembers(R__insp, R__parent);
}

namespace ROOT {
   // Return the actual TClass for the object argument
   static TClass *TGeoCone_IsA(const void *obj) {
      return ((::TGeoCone*)obj)->IsA();
   }
   // Wrappers around operator new
   static void *new_TGeoCone(void *p) {
      return  p ? new(p) ::TGeoCone : new ::TGeoCone;
   }
   static void *newArray_TGeoCone(Long_t size) {
      return new ::TGeoCone[size];
   }
   // 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()) {
      TGeoConeSeg::Class()->ReadBuffer(R__b, this);
   } else {
      TGeoConeSeg::Class()->WriteBuffer(R__b, this);
   }
}

//______________________________________________________________________________
void TGeoConeSeg::ShowMembers(TMemberInspector &R__insp, char *R__parent)
{
      // Inspect the data members of an object of class TGeoConeSeg.

      TClass *R__cl = ::TGeoConeSeg::IsA();
      Int_t R__ncp = strlen(R__parent);
      if (R__ncp || R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__parent, "fPhi1", &fPhi1);
      R__insp.Inspect(R__cl, R__parent, "fPhi2", &fPhi2);
      TGeoCone::ShowMembers(R__insp, R__parent);
}

namespace ROOT {
   // Return the actual TClass for the object argument
   static TClass *TGeoConeSeg_IsA(const void *obj) {
      return ((::TGeoConeSeg*)obj)->IsA();
   }
   // Wrappers around operator new
   static void *new_TGeoConeSeg(void *p) {
      return  p ? new(p) ::TGeoConeSeg : new ::TGeoConeSeg;
   }
   static void *newArray_TGeoConeSeg(Long_t size) {
      return new ::TGeoConeSeg[size];
   }
   // 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()) {
      TGeoParaboloid::Class()->ReadBuffer(R__b, this);
   } else {
      TGeoParaboloid::Class()->WriteBuffer(R__b, this);
   }
}

//______________________________________________________________________________
void TGeoParaboloid::ShowMembers(TMemberInspector &R__insp, char *R__parent)
{
      // Inspect the data members of an object of class TGeoParaboloid.

      TClass *R__cl = ::TGeoParaboloid::IsA();
      Int_t R__ncp = strlen(R__parent);
      if (R__ncp || R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__parent, "fRlo", &fRlo);
      R__insp.Inspect(R__cl, R__parent, "fRhi", &fRhi);
      R__insp.Inspect(R__cl, R__parent, "fDz", &fDz);
      R__insp.Inspect(R__cl, R__parent, "fA", &fA);
      R__insp.Inspect(R__cl, R__parent, "fB", &fB);
      TGeoBBox::ShowMembers(R__insp, R__parent);
}

namespace ROOT {
   // Return the actual TClass for the object argument
   static TClass *TGeoParaboloid_IsA(const void *obj) {
      return ((::TGeoParaboloid*)obj)->IsA();
   }
   // Wrappers around operator new
   static void *new_TGeoParaboloid(void *p) {
      return  p ? new(p) ::TGeoParaboloid : new ::TGeoParaboloid;
   }
   static void *newArray_TGeoParaboloid(Long_t size) {
      return new ::TGeoParaboloid[size];
   }
   // 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()) {
      TGeoPcon::Class()->ReadBuffer(R__b, this);
   } else {
      TGeoPcon::Class()->WriteBuffer(R__b, this);
   }
}

//______________________________________________________________________________
void TGeoPcon::ShowMembers(TMemberInspector &R__insp, char *R__parent)
{
      // Inspect the data members of an object of class TGeoPcon.

      TClass *R__cl = ::TGeoPcon::IsA();
      Int_t R__ncp = strlen(R__parent);
      if (R__ncp || R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__parent, "fNz", &fNz);
      R__insp.Inspect(R__cl, R__parent, "fPhi1", &fPhi1);
      R__insp.Inspect(R__cl, R__parent, "fDphi", &fDphi);
      R__insp.Inspect(R__cl, R__parent, "*fRmin", &fRmin);
      R__insp.Inspect(R__cl, R__parent, "*fRmax", &fRmax);
      R__insp.Inspect(R__cl, R__parent, "*fZ", &fZ);
      TGeoBBox::ShowMembers(R__insp, R__parent);
}

namespace ROOT {
   // Return the actual TClass for the object argument
   static TClass *TGeoPcon_IsA(const void *obj) {
      return ((::TGeoPcon*)obj)->IsA();
   }
   // Wrappers around operator new
   static void *new_TGeoPcon(void *p) {
      return  p ? new(p) ::TGeoPcon : new ::TGeoPcon;
   }
   static void *newArray_TGeoPcon(Long_t size) {
      return new ::TGeoPcon[size];
   }
   // 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()) {
      TGeoPgon::Class()->ReadBuffer(R__b, this);
   } else {
      TGeoPgon::Class()->WriteBuffer(R__b, this);
   }
}

//______________________________________________________________________________
void TGeoPgon::ShowMembers(TMemberInspector &R__insp, char *R__parent)
{
      // Inspect the data members of an object of class TGeoPgon.

      TClass *R__cl = ::TGeoPgon::IsA();
      Int_t R__ncp = strlen(R__parent);
      if (R__ncp || R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__parent, "fNedges", &fNedges);
      TGeoPcon::ShowMembers(R__insp, R__parent);
}

namespace ROOT {
   // Return the actual TClass for the object argument
   static TClass *TGeoPgon_IsA(const void *obj) {
      return ((::TGeoPgon*)obj)->IsA();
   }
   // Wrappers around operator new
   static void *new_TGeoPgon(void *p) {
      return  p ? new(p) ::TGeoPgon : new ::TGeoPgon;
   }
   static void *newArray_TGeoPgon(Long_t size) {
      return new ::TGeoPgon[size];
   }
   // 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::Streamer(TBuffer &R__b)
{
   // Stream an object of class TGeoArb8.

   if (R__b.IsReading()) {
      TGeoArb8::Class()->ReadBuffer(R__b, this);
   } else {
      TGeoArb8::Class()->WriteBuffer(R__b, this);
   }
}

//______________________________________________________________________________
void TGeoArb8::ShowMembers(TMemberInspector &R__insp, char *R__parent)
{
      // Inspect the data members of an object of class TGeoArb8.

      TClass *R__cl = ::TGeoArb8::IsA();
      Int_t R__ncp = strlen(R__parent);
      if (R__ncp || R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__parent, "fDz", &fDz);
      R__insp.Inspect(R__cl, R__parent, "*fTwist", &fTwist);
      R__insp.Inspect(R__cl, R__parent, "fXY[8][2]", fXY);
      TGeoBBox::ShowMembers(R__insp, R__parent);
}

namespace ROOT {
   // Return the actual TClass for the object argument
   static TClass *TGeoArb8_IsA(const void *obj) {
      return ((::TGeoArb8*)obj)->IsA();
   }
   // Wrappers around operator new
   static void *new_TGeoArb8(void *p) {
      return  p ? new(p) ::TGeoArb8 : new ::TGeoArb8;
   }
   static void *newArray_TGeoArb8(Long_t size) {
      return new ::TGeoArb8[size];
   }
   // 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();
   }
} // end of namespace ROOT for class ::TGeoArb8

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

   if (R__b.IsReading()) {
      TGeoTrap::Class()->ReadBuffer(R__b, this);
   } else {
      TGeoTrap::Class()->WriteBuffer(R__b, this);
   }
}

//______________________________________________________________________________
void TGeoTrap::ShowMembers(TMemberInspector &R__insp, char *R__parent)
{
      // Inspect the data members of an object of class TGeoTrap.

      TClass *R__cl = ::TGeoTrap::IsA();
      Int_t R__ncp = strlen(R__parent);
      if (R__ncp || R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__parent, "fTheta", &fTheta);
      R__insp.Inspect(R__cl, R__parent, "fPhi", &fPhi);
      R__insp.Inspect(R__cl, R__parent, "fH1", &fH1);
      R__insp.Inspect(R__cl, R__parent, "fBl1", &fBl1);
      R__insp.Inspect(R__cl, R__parent, "fTl1", &fTl1);
      R__insp.Inspect(R__cl, R__parent, "fAlpha1", &fAlpha1);
      R__insp.Inspect(R__cl, R__parent, "fH2", &fH2);
      R__insp.Inspect(R__cl, R__parent, "fBl2", &fBl2);
      R__insp.Inspect(R__cl, R__parent, "fTl2", &fTl2);
      R__insp.Inspect(R__cl, R__parent, "fAlpha2", &fAlpha2);
      TGeoArb8::ShowMembers(R__insp, R__parent);
}

namespace ROOT {
   // Return the actual TClass for the object argument
   static TClass *TGeoTrap_IsA(const void *obj) {
      return ((::TGeoTrap*)obj)->IsA();
   }
   // Wrappers around operator new
   static void *new_TGeoTrap(void *p) {
      return  p ? new(p) ::TGeoTrap : new ::TGeoTrap;
   }
   static void *newArray_TGeoTrap(Long_t size) {
      return new ::TGeoTrap[size];
   }
   // 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()) {
      TGeoGtra::Class()->ReadBuffer(R__b, this);
   } else {
      TGeoGtra::Class()->WriteBuffer(R__b, this);
   }
}

//______________________________________________________________________________
void TGeoGtra::ShowMembers(TMemberInspector &R__insp, char *R__parent)
{
      // Inspect the data members of an object of class TGeoGtra.

      TClass *R__cl = ::TGeoGtra::IsA();
      Int_t R__ncp = strlen(R__parent);
      if (R__ncp || R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__parent, "fTwistAngle", &fTwistAngle);
      TGeoTrap::ShowMembers(R__insp, R__parent);
}

namespace ROOT {
   // Return the actual TClass for the object argument
   static TClass *TGeoGtra_IsA(const void *obj) {
      return ((::TGeoGtra*)obj)->IsA();
   }
   // Wrappers around operator new
   static void *new_TGeoGtra(void *p) {
      return  p ? new(p) ::TGeoGtra : new ::TGeoGtra;
   }
   static void *newArray_TGeoGtra(Long_t size) {
      return new ::TGeoGtra[size];
   }
   // 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()) {
      TGeoTrd1::Class()->ReadBuffer(R__b, this);
   } else {
      TGeoTrd1::Class()->WriteBuffer(R__b, this);
   }
}

//______________________________________________________________________________
void TGeoTrd1::ShowMembers(TMemberInspector &R__insp, char *R__parent)
{
      // Inspect the data members of an object of class TGeoTrd1.

      TClass *R__cl = ::TGeoTrd1::IsA();
      Int_t R__ncp = strlen(R__parent);
      if (R__ncp || R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__parent, "fDx1", &fDx1);
      R__insp.Inspect(R__cl, R__parent, "fDx2", &fDx2);
      R__insp.Inspect(R__cl, R__parent, "fDy", &fDy);
      R__insp.Inspect(R__cl, R__parent, "fDz", &fDz);
      TGeoBBox::ShowMembers(R__insp, R__parent);
}

namespace ROOT {
   // Return the actual TClass for the object argument
   static TClass *TGeoTrd1_IsA(const void *obj) {
      return ((::TGeoTrd1*)obj)->IsA();
   }
   // Wrappers around operator new
   static void *new_TGeoTrd1(void *p) {
      return  p ? new(p) ::TGeoTrd1 : new ::TGeoTrd1;
   }
   static void *newArray_TGeoTrd1(Long_t size) {
      return new ::TGeoTrd1[size];
   }
   // 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()) {
      TGeoTrd2::Class()->ReadBuffer(R__b, this);
   } else {
      TGeoTrd2::Class()->WriteBuffer(R__b, this);
   }
}

//______________________________________________________________________________
void TGeoTrd2::ShowMembers(TMemberInspector &R__insp, char *R__parent)
{
      // Inspect the data members of an object of class TGeoTrd2.

      TClass *R__cl = ::TGeoTrd2::IsA();
      Int_t R__ncp = strlen(R__parent);
      if (R__ncp || R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__parent, "fDx1", &fDx1);
      R__insp.Inspect(R__cl, R__parent, "fDx2", &fDx2);
      R__insp.Inspect(R__cl, R__parent, "fDy1", &fDy1);
      R__insp.Inspect(R__cl, R__parent, "fDy2", &fDy2);
      R__insp.Inspect(R__cl, R__parent, "fDz", &fDz);
      TGeoBBox::ShowMembers(R__insp, R__parent);
}

namespace ROOT {
   // Return the actual TClass for the object argument
   static TClass *TGeoTrd2_IsA(const void *obj) {
      return ((::TGeoTrd2*)obj)->IsA();
   }
   // Wrappers around operator new
   static void *new_TGeoTrd2(void *p) {
      return  p ? new(p) ::TGeoTrd2 : new ::TGeoTrd2;
   }
   static void *newArray_TGeoTrd2(Long_t size) {
      return new ::TGeoTrd2[size];
   }
   // 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()) {
      TGeoCompositeShape::Class()->ReadBuffer(R__b, this);
   } else {
      TGeoCompositeShape::Class()->WriteBuffer(R__b, this);
   }
}

//______________________________________________________________________________
void TGeoCompositeShape::ShowMembers(TMemberInspector &R__insp, char *R__parent)
{
      // Inspect the data members of an object of class TGeoCompositeShape.

      TClass *R__cl = ::TGeoCompositeShape::IsA();
      Int_t R__ncp = strlen(R__parent);
      if (R__ncp || R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__parent, "*fNode", &fNode);
      TGeoBBox::ShowMembers(R__insp, R__parent);
}

namespace ROOT {
   // Return the actual TClass for the object argument
   static TClass *TGeoCompositeShape_IsA(const void *obj) {
      return ((::TGeoCompositeShape*)obj)->IsA();
   }
   // Wrappers around operator new
   static void *new_TGeoCompositeShape(void *p) {
      return  p ? new(p) ::TGeoCompositeShape : new ::TGeoCompositeShape;
   }
   static void *newArray_TGeoCompositeShape(Long_t size) {
      return new ::TGeoCompositeShape[size];
   }
   // 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()) {
      TGeoPolygon::Class()->ReadBuffer(R__b, this);
   } else {
      TGeoPolygon::Class()->WriteBuffer(R__b, this);
   }
}

//______________________________________________________________________________
void TGeoPolygon::ShowMembers(TMemberInspector &R__insp, char *R__parent)
{
      // Inspect the data members of an object of class TGeoPolygon.

      TClass *R__cl = ::TGeoPolygon::IsA();
      Int_t R__ncp = strlen(R__parent);
      if (R__ncp || R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__parent, "fNvert", &fNvert);
      R__insp.Inspect(R__cl, R__parent, "fNconvex", &fNconvex);
      R__insp.Inspect(R__cl, R__parent, "*fInd", &fInd);
      R__insp.Inspect(R__cl, R__parent, "*fIndc", &fIndc);
      R__insp.Inspect(R__cl, R__parent, "*fX", &fX);
      R__insp.Inspect(R__cl, R__parent, "*fY", &fY);
      R__insp.Inspect(R__cl, R__parent, "*fDaughters", &fDaughters);
      TObject::ShowMembers(R__insp, R__parent);
}

namespace ROOT {
   // Return the actual TClass for the object argument
   static TClass *TGeoPolygon_IsA(const void *obj) {
      return ((::TGeoPolygon*)obj)->IsA();
   }
   // Wrappers around operator new
   static void *new_TGeoPolygon(void *p) {
      return  p ? new(p) ::TGeoPolygon : new ::TGeoPolygon;
   }
   static void *newArray_TGeoPolygon(Long_t size) {
      return new ::TGeoPolygon[size];
   }
   // 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::Streamer(TBuffer &R__b)
{
   // Stream an object of class TGeoXtru.

   if (R__b.IsReading()) {
      TGeoXtru::Class()->ReadBuffer(R__b, this);
   } else {
      TGeoXtru::Class()->WriteBuffer(R__b, this);
   }
}

//______________________________________________________________________________
void TGeoXtru::ShowMembers(TMemberInspector &R__insp, char *R__parent)
{
      // Inspect the data members of an object of class TGeoXtru.

      TClass *R__cl = ::TGeoXtru::IsA();
      Int_t R__ncp = strlen(R__parent);
      if (R__ncp || R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__parent, "fNvert", &fNvert);
      R__insp.Inspect(R__cl, R__parent, "fNz", &fNz);
      R__insp.Inspect(R__cl, R__parent, "fZcurrent", &fZcurrent);
      R__insp.Inspect(R__cl, R__parent, "*fPoly", &fPoly);
      R__insp.Inspect(R__cl, R__parent, "*fX", &fX);
      R__insp.Inspect(R__cl, R__parent, "*fY", &fY);
      R__insp.Inspect(R__cl, R__parent, "*fXc", &fXc);
      R__insp.Inspect(R__cl, R__parent, "*fYc", &fYc);
      R__insp.Inspect(R__cl, R__parent, "*fZ", &fZ);
      R__insp.Inspect(R__cl, R__parent, "*fScale", &fScale);
      R__insp.Inspect(R__cl, R__parent, "*fX0", &fX0);
      R__insp.Inspect(R__cl, R__parent, "*fY0", &fY0);
      R__insp.Inspect(R__cl, R__parent, "fSeg", &fSeg);
      R__insp.Inspect(R__cl, R__parent, "fIz", &fIz);
      TGeoBBox::ShowMembers(R__insp, R__parent);
}

namespace ROOT {
   // Return the actual TClass for the object argument
   static TClass *TGeoXtru_IsA(const void *obj) {
      return ((::TGeoXtru*)obj)->IsA();
   }
   // Wrappers around operator new
   static void *new_TGeoXtru(void *p) {
      return  p ? new(p) ::TGeoXtru : new ::TGeoXtru;
   }
   static void *newArray_TGeoXtru(Long_t size) {
      return new ::TGeoXtru[size];
   }
   // 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();
   }
} // end of namespace ROOT for class ::TGeoXtru

//______________________________________________________________________________
void TGeoVolume::ShowMembers(TMemberInspector &R__insp, char *R__parent)
{
      // Inspect the data members of an object of class TGeoVolume.

      TClass *R__cl = ::TGeoVolume::IsA();
      Int_t R__ncp = strlen(R__parent);
      if (R__ncp || R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__parent, "*fNodes", &fNodes);
      R__insp.Inspect(R__cl, R__parent, "*fShape", &fShape);
      R__insp.Inspect(R__cl, R__parent, "*fMedium", &fMedium);
      R__insp.Inspect(R__cl, R__parent, "*fFinder", &fFinder);
      R__insp.Inspect(R__cl, R__parent, "*fVoxels", &fVoxels);
      R__insp.Inspect(R__cl, R__parent, "*fGeoManager", &fGeoManager);
      R__insp.Inspect(R__cl, R__parent, "*fField", &fField);
      R__insp.Inspect(R__cl, R__parent, "fOption", &fOption);
      fOption.ShowMembers(R__insp, strcat(R__parent,"fOption.")); R__parent[R__ncp] = 0;
      R__insp.Inspect(R__cl, R__parent, "fNumber", &fNumber);
      R__insp.Inspect(R__cl, R__parent, "fNtotal", &fNtotal);
      TNamed::ShowMembers(R__insp, R__parent);
      TGeoAtt::ShowMembers(R__insp, R__parent);
      TAttLine::ShowMembers(R__insp, R__parent);
      TAttFill::ShowMembers(R__insp, R__parent);
      TAtt3D::ShowMembers(R__insp, R__parent);
}

namespace ROOT {
   // Return the actual TClass for the object argument
   static TClass *TGeoVolume_IsA(const void *obj) {
      return ((::TGeoVolume*)obj)->IsA();
   }
   // Wrappers around operator new
   static void *new_TGeoVolume(void *p) {
      return  p ? new(p) ::TGeoVolume : new ::TGeoVolume;
   }
   static void *newArray_TGeoVolume(Long_t size) {
      return new ::TGeoVolume[size];
   }
   // 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();
   }
} // end of namespace ROOT for class ::TGeoVolume

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

   if (R__b.IsReading()) {
      TGeoVolumeAssembly::Class()->ReadBuffer(R__b, this);
   } else {
      TGeoVolumeAssembly::Class()->WriteBuffer(R__b, this);
   }
}

//______________________________________________________________________________
void TGeoVolumeAssembly::ShowMembers(TMemberInspector &R__insp, char *R__parent)
{
      // Inspect the data members of an object of class TGeoVolumeAssembly.

      TClass *R__cl = ::TGeoVolumeAssembly::IsA();
      Int_t R__ncp = strlen(R__parent);
      if (R__ncp || R__cl || R__insp.IsA()) { }
      TGeoVolume::ShowMembers(R__insp, R__parent);
}

namespace ROOT {
   // Return the actual TClass for the object argument
   static TClass *TGeoVolumeAssembly_IsA(const void *obj) {
      return ((::TGeoVolumeAssembly*)obj)->IsA();
   }
   // Wrappers around operator new
   static void *new_TGeoVolumeAssembly(void *p) {
      return  p ? new(p) ::TGeoVolumeAssembly : new ::TGeoVolumeAssembly;
   }
   static void *newArray_TGeoVolumeAssembly(Long_t size) {
      return new ::TGeoVolumeAssembly[size];
   }
   // 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()) {
      TGeoVolumeMulti::Class()->ReadBuffer(R__b, this);
   } else {
      TGeoVolumeMulti::Class()->WriteBuffer(R__b, this);
   }
}

//______________________________________________________________________________
void TGeoVolumeMulti::ShowMembers(TMemberInspector &R__insp, char *R__parent)
{
      // Inspect the data members of an object of class TGeoVolumeMulti.

      TClass *R__cl = ::TGeoVolumeMulti::IsA();
      Int_t R__ncp = strlen(R__parent);
      if (R__ncp || R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__parent, "*fVolumes", &fVolumes);
      R__insp.Inspect(R__cl, R__parent, "*fDivision", &fDivision);
      R__insp.Inspect(R__cl, R__parent, "fNumed", &fNumed);
      R__insp.Inspect(R__cl, R__parent, "fNdiv", &fNdiv);
      R__insp.Inspect(R__cl, R__parent, "fAxis", &fAxis);
      R__insp.Inspect(R__cl, R__parent, "fStart", &fStart);
      R__insp.Inspect(R__cl, R__parent, "fStep", &fStep);
      R__insp.Inspect(R__cl, R__parent, "fAttSet", &fAttSet);
      TGeoVolume::ShowMembers(R__insp, R__parent);
}

namespace ROOT {
   // Return the actual TClass for the object argument
   static TClass *TGeoVolumeMulti_IsA(const void *obj) {
      return ((::TGeoVolumeMulti*)obj)->IsA();
   }
   // Wrappers around operator new
   static void *new_TGeoVolumeMulti(void *p) {
      return  p ? new(p) ::TGeoVolumeMulti : new ::TGeoVolumeMulti;
   }
   static void *newArray_TGeoVolumeMulti(Long_t size) {
      return new ::TGeoVolumeMulti[size];
   }
   // 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()) {
      TGeoNode::Class()->ReadBuffer(R__b, this);
   } else {
      TGeoNode::Class()->WriteBuffer(R__b, this);
   }
}

//______________________________________________________________________________
void TGeoNode::ShowMembers(TMemberInspector &R__insp, char *R__parent)
{
      // Inspect the data members of an object of class TGeoNode.

      TClass *R__cl = ::TGeoNode::IsA();
      Int_t R__ncp = strlen(R__parent);
      if (R__ncp || R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__parent, "*fVolume", &fVolume);
      R__insp.Inspect(R__cl, R__parent, "*fMother", &fMother);
      R__insp.Inspect(R__cl, R__parent, "fNumber", &fNumber);
      R__insp.Inspect(R__cl, R__parent, "fNovlp", &fNovlp);
      R__insp.Inspect(R__cl, R__parent, "*fOverlaps", &fOverlaps);
      TNamed::ShowMembers(R__insp, R__parent);
      TGeoAtt::ShowMembers(R__insp, R__parent);
}

namespace ROOT {
   // Return the actual TClass for the object argument
   static TClass *TGeoNode_IsA(const void *obj) {
      return ((::TGeoNode*)obj)->IsA();
   }
   // 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()) {
      TGeoPhysicalNode::Class()->ReadBuffer(R__b, this);
   } else {
      TGeoPhysicalNode::Class()->WriteBuffer(R__b, this);
   }
}

//______________________________________________________________________________
void TGeoPhysicalNode::ShowMembers(TMemberInspector &R__insp, char *R__parent)
{
      // Inspect the data members of an object of class TGeoPhysicalNode.

      TClass *R__cl = ::TGeoPhysicalNode::IsA();
      Int_t R__ncp = strlen(R__parent);
      if (R__ncp || R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__parent, "fLevel", &fLevel);
      R__insp.Inspect(R__cl, R__parent, "*fMatrices", &fMatrices);
      R__insp.Inspect(R__cl, R__parent, "*fNodes", &fNodes);
      TObject::ShowMembers(R__insp, R__parent);
      TAttLine::ShowMembers(R__insp, R__parent);
}

namespace ROOT {
   // Return the actual TClass for the object argument
   static TClass *TGeoPhysicalNode_IsA(const void *obj) {
      return ((::TGeoPhysicalNode*)obj)->IsA();
   }
   // Wrappers around operator new
   static void *new_TGeoPhysicalNode(void *p) {
      return  p ? new(p) ::TGeoPhysicalNode : new ::TGeoPhysicalNode;
   }
   static void *newArray_TGeoPhysicalNode(Long_t size) {
      return new ::TGeoPhysicalNode[size];
   }
   // 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 TGeoNodeMatrix::Streamer(TBuffer &R__b)
{
   // Stream an object of class TGeoNodeMatrix.

   if (R__b.IsReading()) {
      TGeoNodeMatrix::Class()->ReadBuffer(R__b, this);
   } else {
      TGeoNodeMatrix::Class()->WriteBuffer(R__b, this);
   }
}

//______________________________________________________________________________
void TGeoNodeMatrix::ShowMembers(TMemberInspector &R__insp, char *R__parent)
{
      // Inspect the data members of an object of class TGeoNodeMatrix.

      TClass *R__cl = ::TGeoNodeMatrix::IsA();
      Int_t R__ncp = strlen(R__parent);
      if (R__ncp || R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__parent, "*fMatrix", &fMatrix);
      TGeoNode::ShowMembers(R__insp, R__parent);
}

namespace ROOT {
   // Return the actual TClass for the object argument
   static TClass *TGeoNodeMatrix_IsA(const void *obj) {
      return ((::TGeoNodeMatrix*)obj)->IsA();
   }
   // Wrappers around operator new
   static void *new_TGeoNodeMatrix(void *p) {
      return  p ? new(p) ::TGeoNodeMatrix : new ::TGeoNodeMatrix;
   }
   static void *newArray_TGeoNodeMatrix(Long_t size) {
      return new ::TGeoNodeMatrix[size];
   }
   // 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()) {
      TGeoNodeOffset::Class()->ReadBuffer(R__b, this);
   } else {
      TGeoNodeOffset::Class()->WriteBuffer(R__b, this);
   }
}

//______________________________________________________________________________
void TGeoNodeOffset::ShowMembers(TMemberInspector &R__insp, char *R__parent)
{
      // Inspect the data members of an object of class TGeoNodeOffset.

      TClass *R__cl = ::TGeoNodeOffset::IsA();
      Int_t R__ncp = strlen(R__parent);
      if (R__ncp || R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__parent, "fOffset", &fOffset);
      R__insp.Inspect(R__cl, R__parent, "fIndex", &fIndex);
      R__insp.Inspect(R__cl, R__parent, "*fFinder", &fFinder);
      TGeoNode::ShowMembers(R__insp, R__parent);
}

namespace ROOT {
   // Return the actual TClass for the object argument
   static TClass *TGeoNodeOffset_IsA(const void *obj) {
      return ((::TGeoNodeOffset*)obj)->IsA();
   }
   // Wrappers around operator new
   static void *new_TGeoNodeOffset(void *p) {
      return  p ? new(p) ::TGeoNodeOffset : new ::TGeoNodeOffset;
   }
   static void *newArray_TGeoNodeOffset(Long_t size) {
      return new ::TGeoNodeOffset[size];
   }
   // 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, char *R__parent)
{
      // Inspect the data members of an object of class TGeoManager.

      TClass *R__cl = ::TGeoManager::IsA();
      Int_t R__ncp = strlen(R__parent);
      if (R__ncp || R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__parent, "fStep", &fStep);
      R__insp.Inspect(R__cl, R__parent, "fSafety", &fSafety);
      R__insp.Inspect(R__cl, R__parent, "fLastSafety", &fLastSafety);
      R__insp.Inspect(R__cl, R__parent, "fPhimin", &fPhimin);
      R__insp.Inspect(R__cl, R__parent, "fPhimax", &fPhimax);
      R__insp.Inspect(R__cl, R__parent, "fTmin", &fTmin);
      R__insp.Inspect(R__cl, R__parent, "fTmax", &fTmax);
      R__insp.Inspect(R__cl, R__parent, "fLevel", &fLevel);
      R__insp.Inspect(R__cl, R__parent, "fNNodes", &fNNodes);
      R__insp.Inspect(R__cl, R__parent, "fPath", &fPath);
      fPath.ShowMembers(R__insp, strcat(R__parent,"fPath.")); R__parent[R__ncp] = 0;
      R__insp.Inspect(R__cl, R__parent, "fParticleName", &fParticleName);
      fParticleName.ShowMembers(R__insp, strcat(R__parent,"fParticleName.")); R__parent[R__ncp] = 0;
      R__insp.Inspect(R__cl, R__parent, "fNormal[3]", fNormal);
      R__insp.Inspect(R__cl, R__parent, "*fCldir", &fCldir);
      R__insp.Inspect(R__cl, R__parent, "*fCldirChecked", &fCldirChecked);
      R__insp.Inspect(R__cl, R__parent, "*fPoint", &fPoint);
      R__insp.Inspect(R__cl, R__parent, "*fDirection", &fDirection);
      R__insp.Inspect(R__cl, R__parent, "fVisDensity", &fVisDensity);
      R__insp.Inspect(R__cl, R__parent, "fExplodedView", &fExplodedView);
      R__insp.Inspect(R__cl, R__parent, "fVisOption", &fVisOption);
      R__insp.Inspect(R__cl, R__parent, "fVisLevel", &fVisLevel);
      R__insp.Inspect(R__cl, R__parent, "fNsegments", &fNsegments);
      R__insp.Inspect(R__cl, R__parent, "fNtracks", &fNtracks);
      R__insp.Inspect(R__cl, R__parent, "fMaxVisNodes", &fMaxVisNodes);
      R__insp.Inspect(R__cl, R__parent, "*fCurrentTrack", &fCurrentTrack);
      R__insp.Inspect(R__cl, R__parent, "fNpdg", &fNpdg);
      R__insp.Inspect(R__cl, R__parent, "fPdgId[256]", fPdgId);
      R__insp.Inspect(R__cl, R__parent, "fSearchOverlaps", &fSearchOverlaps);
      R__insp.Inspect(R__cl, R__parent, "fCurrentOverlapping", &fCurrentOverlapping);
      R__insp.Inspect(R__cl, R__parent, "fLoopVolumes", &fLoopVolumes);
      R__insp.Inspect(R__cl, R__parent, "fStartSafe", &fStartSafe);
      R__insp.Inspect(R__cl, R__parent, "fIsEntering", &fIsEntering);
      R__insp.Inspect(R__cl, R__parent, "fIsExiting", &fIsExiting);
      R__insp.Inspect(R__cl, R__parent, "fIsStepEntering", &fIsStepEntering);
      R__insp.Inspect(R__cl, R__parent, "fIsStepExiting", &fIsStepExiting);
      R__insp.Inspect(R__cl, R__parent, "fIsOutside", &fIsOutside);
      R__insp.Inspect(R__cl, R__parent, "fIsOnBoundary", &fIsOnBoundary);
      R__insp.Inspect(R__cl, R__parent, "fIsSameLocation", &fIsSameLocation);
      R__insp.Inspect(R__cl, R__parent, "fIsNullStep", &fIsNullStep);
      R__insp.Inspect(R__cl, R__parent, "fStreamVoxels", &fStreamVoxels);
      R__insp.Inspect(R__cl, R__parent, "fIsGeomReading", &fIsGeomReading);
      R__insp.Inspect(R__cl, R__parent, "fPhiCut", &fPhiCut);
      R__insp.Inspect(R__cl, R__parent, "fTimeCut", &fTimeCut);
      R__insp.Inspect(R__cl, R__parent, "fDrawExtra", &fDrawExtra);
      R__insp.Inspect(R__cl, R__parent, "fMatrixTransform", &fMatrixTransform);
      R__insp.Inspect(R__cl, R__parent, "fMatrixReflection", &fMatrixReflection);
      R__insp.Inspect(R__cl, R__parent, "*fCache", &fCache);
      R__insp.Inspect(R__cl, R__parent, "*fPainter", &fPainter);
      R__insp.Inspect(R__cl, R__parent, "*fMatrices", &fMatrices);
      R__insp.Inspect(R__cl, R__parent, "*fShapes", &fShapes);
      R__insp.Inspect(R__cl, R__parent, "*fVolumes", &fVolumes);
      R__insp.Inspect(R__cl, R__parent, "*fPhysicalNodes", &fPhysicalNodes);
      R__insp.Inspect(R__cl, R__parent, "*fGShapes", &fGShapes);
      R__insp.Inspect(R__cl, R__parent, "*fGVolumes", &fGVolumes);
      R__insp.Inspect(R__cl, R__parent, "*fTracks", &fTracks);
      R__insp.Inspect(R__cl, R__parent, "*fPdgNames", &fPdgNames);
      R__insp.Inspect(R__cl, R__parent, "*fMaterials", &fMaterials);
      R__insp.Inspect(R__cl, R__parent, "*fMedia", &fMedia);
      R__insp.Inspect(R__cl, R__parent, "*fNodes", &fNodes);
      R__insp.Inspect(R__cl, R__parent, "*fOverlaps", &fOverlaps);
      R__insp.Inspect(R__cl, R__parent, "*fBits", &fBits);
      R__insp.Inspect(R__cl, R__parent, "*fCurrentVolume", &fCurrentVolume);
      R__insp.Inspect(R__cl, R__parent, "*fTopVolume", &fTopVolume);
      R__insp.Inspect(R__cl, R__parent, "*fCurrentNode", &fCurrentNode);
      R__insp.Inspect(R__cl, R__parent, "*fTopNode", &fTopNode);
      R__insp.Inspect(R__cl, R__parent, "*fLastNode", &fLastNode);
      R__insp.Inspect(R__cl, R__parent, "*fNextNode", &fNextNode);
      R__insp.Inspect(R__cl, R__parent, "*fMasterVolume", &fMasterVolume);
      R__insp.Inspect(R__cl, R__parent, "*fCurrentMatrix", &fCurrentMatrix);
      R__insp.Inspect(R__cl, R__parent, "*fGLMatrix", &fGLMatrix);
      R__insp.Inspect(R__cl, R__parent, "*fUniqueVolumes", &fUniqueVolumes);
      R__insp.Inspect(R__cl, R__parent, "*fClippingShape", &fClippingShape);
      R__insp.Inspect(R__cl, R__parent, "*fElementTable", &fElementTable);
      R__insp.Inspect(R__cl, R__parent, "*fNodeIdArray", &fNodeIdArray);
      R__insp.Inspect(R__cl, R__parent, "fIntSize", &fIntSize);
      R__insp.Inspect(R__cl, R__parent, "fDblSize", &fDblSize);
      R__insp.Inspect(R__cl, R__parent, "fOverlapSize", &fOverlapSize);
      R__insp.Inspect(R__cl, R__parent, "fOverlapMark", &fOverlapMark);
      R__insp.Inspect(R__cl, R__parent, "*fIntBuffer", &fIntBuffer);
      R__insp.Inspect(R__cl, R__parent, "*fOverlapClusters", &fOverlapClusters);
      R__insp.Inspect(R__cl, R__parent, "*fDblBuffer", &fDblBuffer);
      R__insp.Inspect(R__cl, R__parent, "fLastPoint[3]", fLastPoint);
      R__insp.Inspect(R__cl, R__parent, "*fPaintVolume", &fPaintVolume);
      TNamed::ShowMembers(R__insp, R__parent);
}

namespace ROOT {
   // Return the actual TClass for the object argument
   static TClass *TGeoManager_IsA(const void *obj) {
      return ((::TGeoManager*)obj)->IsA();
   }
   // Wrappers around operator new
   static void *new_TGeoManager(void *p) {
      return  p ? new(p) ::TGeoManager : new ::TGeoManager;
   }
   static void *newArray_TGeoManager(Long_t size) {
      return new ::TGeoManager[size];
   }
   // 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();
   }
} // end of namespace ROOT for class ::TGeoManager

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

   if (R__b.IsReading()) {
      TVirtualGeoPainter::Class()->ReadBuffer(R__b, this);
   } else {
      TVirtualGeoPainter::Class()->WriteBuffer(R__b, this);
   }
}

//______________________________________________________________________________
void TVirtualGeoPainter::ShowMembers(TMemberInspector &R__insp, char *R__parent)
{
      // Inspect the data members of an object of class TVirtualGeoPainter.

      TClass *R__cl = ::TVirtualGeoPainter::IsA();
      Int_t R__ncp = strlen(R__parent);
      if (R__ncp || R__cl || R__insp.IsA()) { }
      TObject::ShowMembers(R__insp, R__parent);
}

namespace ROOT {
   // Return the actual TClass for the object argument
   static TClass *TVirtualGeoPainter_IsA(const void *obj) {
      return ((::TVirtualGeoPainter*)obj)->IsA();
   }
   // 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()) {
      TVirtualGeoTrack::Class()->ReadBuffer(R__b, this);
   } else {
      TVirtualGeoTrack::Class()->WriteBuffer(R__b, this);
   }
}

//______________________________________________________________________________
void TVirtualGeoTrack::ShowMembers(TMemberInspector &R__insp, char *R__parent)
{
      // Inspect the data members of an object of class TVirtualGeoTrack.

      TClass *R__cl = ::TVirtualGeoTrack::IsA();
      Int_t R__ncp = strlen(R__parent);
      if (R__ncp || R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__parent, "fPDG", &fPDG);
      R__insp.Inspect(R__cl, R__parent, "fId", &fId);
      R__insp.Inspect(R__cl, R__parent, "*fParent", &fParent);
      R__insp.Inspect(R__cl, R__parent, "*fParticle", &fParticle);
      R__insp.Inspect(R__cl, R__parent, "*fTracks", &fTracks);
      TObject::ShowMembers(R__insp, R__parent);
      TGeoAtt::ShowMembers(R__insp, R__parent);
      TAttLine::ShowMembers(R__insp, R__parent);
      TAttMarker::ShowMembers(R__insp, R__parent);
}

namespace ROOT {
   // Return the actual TClass for the object argument
   static TClass *TVirtualGeoTrack_IsA(const void *obj) {
      return ((::TVirtualGeoTrack*)obj)->IsA();
   }
   // 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

/********************************************************
* 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

extern "C" void G__cpp_reset_tagtableG__Geom1();

extern "C" void G__set_cpp_environmentG__Geom1() {
  G__add_compiledheader("base/inc/TROOT.h");
  G__add_compiledheader("base/inc/TMemberInspector.h");
  G__add_compiledheader("geom/inc/TGeoAtt.h");
  G__add_compiledheader("geom/inc/TGeoBoolNode.h");
  G__add_compiledheader("geom/inc/TGeoMedium.h");
  G__add_compiledheader("geom/inc/TGeoMaterial.h");
  G__add_compiledheader("geom/inc/TGeoMatrix.h");
  G__add_compiledheader("geom/inc/TGeoVolume.h");
  G__add_compiledheader("geom/inc/TGeoNode.h");
  G__add_compiledheader("geom/inc/TGeoVoxelFinder.h");
  G__add_compiledheader("geom/inc/TGeoShape.h");
  G__add_compiledheader("geom/inc/TGeoBBox.h");
  G__add_compiledheader("geom/inc/TGeoPara.h");
  G__add_compiledheader("geom/inc/TGeoTube.h");
  G__add_compiledheader("geom/inc/TGeoTorus.h");
  G__add_compiledheader("geom/inc/TGeoSphere.h");
  G__add_compiledheader("geom/inc/TGeoEltu.h");
  G__add_compiledheader("geom/inc/TGeoHype.h");
  G__add_compiledheader("geom/inc/TGeoCone.h");
  G__add_compiledheader("geom/inc/TGeoPcon.h");
  G__add_compiledheader("geom/inc/TGeoPgon.h");
  G__add_compiledheader("geom/inc/TGeoArb8.h");
  G__add_compiledheader("geom/inc/TGeoTrd1.h");
  G__add_compiledheader("geom/inc/TGeoTrd2.h");
  G__add_compiledheader("geom/inc/TGeoManager.h");
  G__add_compiledheader("geom/inc/TGeoCompositeShape.h");
  G__add_compiledheader("geom/inc/TVirtualGeoPainter.h");
  G__add_compiledheader("geom/inc/TVirtualGeoTrack.h");
  G__add_compiledheader("geom/inc/TGeoPolygon.h");
  G__add_compiledheader("geom/inc/TGeoXtru.h");
  G__add_compiledheader("geom/inc/TGeoPhysicalNode.h");
  G__add_compiledheader("geom/inc/TGeoHelix.h");
  G__add_compiledheader("geom/inc/TGeoParaboloid.h");
  G__add_compiledheader("geom/inc/TGeoElement.h");
  G__add_compiledheader("geom/inc/TGeoHalfSpace.h");
  G__cpp_reset_tagtableG__Geom1();
}
class G__geomdIsrcdIG__Geom1dOcxx_tag {};

void* operator new(size_t size,G__geomdIsrcdIG__Geom1dOcxx_tag* p) {
  if(p && G__PVOID!=G__getgvp()) return((void*)p);
#ifndef G__ROOT
  return(malloc(size));
#else
  return(::operator new(size));
#endif
}

/* dummy, for exception */
#ifdef G__EH_DUMMY_DELETE
void operator delete(void *p,G__geomdIsrcdIG__Geom1dOcxx_tag* x) {
  if((long)p==G__getgvp() && G__PVOID!=G__getgvp()) return;
#ifndef G__ROOT
  free(p);
#else
  ::operator delete(p);
#endif
}
#endif

static void G__operator_delete(void *p) {
  if((long)p==G__getgvp() && G__PVOID!=G__getgvp()) return;
#ifndef G__ROOT
  free(p);
#else
  ::operator delete(p);
#endif
}

void G__DELDMY_geomdIsrcdIG__Geom1dOcxx() { G__operator_delete(0); }

extern "C" int G__cpp_dllrevG__Geom1() { return(30051515); }

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

/* TGeoAtt */
static int G__G__Geom1_131_1_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   TGeoAtt *p=NULL;
   if(G__getaryconstruct()) p=new TGeoAtt[G__getaryconstruct()];
   else p=::new((G__geomdIsrcdIG__Geom1dOcxx_tag*)G__getgvp()) TGeoAtt;
      result7->obj.i = (long)p;
      result7->ref = (long)p;
      result7->type = 'u';
      result7->tagnum = G__get_linked_tagnum(&G__G__Geom1LN_TGeoAtt);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_131_2_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   TGeoAtt *p=NULL;
   switch(libp->paran) {
   case 3:
      p = ::new((G__geomdIsrcdIG__Geom1dOcxx_tag*)G__getgvp()) 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:
      p = ::new((G__geomdIsrcdIG__Geom1dOcxx_tag*)G__getgvp()) TGeoAtt((Option_t*)G__int(libp->para[0]),(Option_t*)G__int(libp->para[1]));
      break;
   case 1:
      p = ::new((G__geomdIsrcdIG__Geom1dOcxx_tag*)G__getgvp()) TGeoAtt((Option_t*)G__int(libp->para[0]));
      break;
   }
      result7->obj.i = (long)p;
      result7->ref = (long)p;
      result7->type = 'u';
      result7->tagnum = G__get_linked_tagnum(&G__G__Geom1LN_TGeoAtt);
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

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

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

static int G__G__Geom1_131_4_1(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_131_5_1(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_131_6_1(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_131_7_1(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_131_8_1(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_131_9_1(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_131_0_2(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_131_1_2(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_131_2_2(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_131_3_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      TGeoAtt::Dictionary();
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_131_4_2(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_131_5_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoAtt*)(G__getstructoffset()))->ShowMembers(*(TMemberInspector*)libp->para[0].ref,(char*)G__int(libp->para[1]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_131_6_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoAtt*)(G__getstructoffset()))->Streamer(*(TBuffer*)libp->para[0].ref);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_131_7_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoAtt*)(G__getstructoffset()))->StreamerNVirtual(*(TBuffer*)libp->para[0].ref);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_131_8_2(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_131_9_2(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_131_0_3(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_131_1_3(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_131_2_3(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash)
{
   TGeoAtt *p;
   void *xtmp = (void*)G__int(libp->para[0]);
   p=new TGeoAtt(*(TGeoAtt*)xtmp);
   result7->obj.i = (long)p;
   result7->ref = (long)p;
   result7->type = 'u';
   result7->tagnum = 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_131_3_3(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   if(0==G__getstructoffset()) return(1);
   if(G__getaryconstruct())
     if(G__PVOID==G__getgvp())
       delete[] (TGeoAtt *)(G__getstructoffset());
     else
       for(int i=G__getaryconstruct()-1;i>=0;i--)
         ((TGeoAtt *)((G__getstructoffset())+sizeof(TGeoAtt)*i))->~G__TTGeoAtt();
   else {
     long G__Xtmp=G__getgvp();
     G__setgvp(G__PVOID);
     ((TGeoAtt *)(G__getstructoffset()))->~G__TTGeoAtt();
     G__setgvp(G__Xtmp);
     G__operator_delete((void*)G__getstructoffset());
   }
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__G__Geom1_131_4_3(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_137_7_0(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_137_8_0(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_137_9_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoShape*)(G__getstructoffset()))->ComputeBBox();
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_137_0_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((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]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_137_1_1(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_137_2_1(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_137_3_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__letint(result7,105,(long)((TGeoShape*)(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_137_4_1(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_137_5_1(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_137_6_1(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_137_7_1(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_137_8_1(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_137_9_1(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_137_0_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((const TGeoShape*)(G__getstructoffset()))->GetBoundingCylinder((Double_t*)G__int(libp->para[0]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_137_1_2(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_137_2_2(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_137_3_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__letint(result7,105,(long)((const TGeoShape*)(G__getstructoffset()))->GetFittingBox((const 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_137_4_2(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_137_5_2(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_137_6_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   G__letint(result7,67,(long)((const TGeoShape*)(G__getstructoffset()))->GetName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_137_7_2(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_137_8_2(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_137_9_2(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_137_0_3(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_137_1_3(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_137_2_3(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_137_3_3(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_137_4_3(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_137_5_3(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_137_6_3(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((const TGeoShape*)(G__getstructoffset()))->InspectShape();
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_137_7_3(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_137_8_3(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      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]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_137_9_3(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_137_0_4(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_137_1_4(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoShape*)(G__getstructoffset()))->SetDimensions((Double_t*)G__int(libp->para[0]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_137_2_4(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoShape*)(G__getstructoffset()))->SetId((Int_t)G__int(libp->para[0]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_137_3_4(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((const TGeoShape*)(G__getstructoffset()))->SetPoints((Double_t*)G__int(libp->para[0]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_137_4_4(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((const TGeoShape*)(G__getstructoffset()))->SetPoints((Float_t*)G__int(libp->para[0]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_137_5_4(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((const TGeoShape*)(G__getstructoffset()))->SetSegsAndPols(*(TBuffer3D*)libp->para[0].ref);
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__Geom1_137_7_4(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_137_8_4(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((const TGeoShape*)(G__getstructoffset()))->Sizeof3D();
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_137_9_4(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoShape*)(G__getstructoffset()))->SetShapeBit((UInt_t)G__int(libp->para[0]),(Bool_t)G__int(libp->para[1]));
   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) {
      G__setnull(result7);
      ((TGeoShape*)(G__getstructoffset()))->SetShapeBit((UInt_t)G__int(libp->para[0]));
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__Geom1_137_2_5(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_137_3_5(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_137_4_5(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoShape*)(G__getstructoffset()))->InvertShapeBit((UInt_t)G__int(libp->para[0]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_137_5_5(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_137_6_5(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_137_7_5(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_137_8_5(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      TGeoShape::Dictionary();
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_137_9_5(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   G__letint(result7,85,(long)((const TGeoShape*)(G__getstructoffset()))->IsA());
   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) {
      G__setnull(result7);
      ((TGeoShape*)(G__getstructoffset()))->ShowMembers(*(TMemberInspector*)libp->para[0].ref,(char*)G__int(libp->para[1]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_137_1_6(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoShape*)(G__getstructoffset()))->Streamer(*(TBuffer*)libp->para[0].ref);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_137_2_6(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoShape*)(G__getstructoffset()))->StreamerNVirtual(*(TBuffer*)libp->para[0].ref);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_137_3_6(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_137_4_6(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_137_5_6(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_137_6_6(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_137_7_6(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   if(0==G__getstructoffset()) return(1);
   if(G__getaryconstruct())
     if(G__PVOID==G__getgvp())
       delete[] (TGeoShape *)(G__getstructoffset());
     else
       for(int i=G__getaryconstruct()-1;i>=0;i--)
         delete (TGeoShape *)((G__getstructoffset())+sizeof(TGeoShape)*i);
   else  delete (TGeoShape *)(G__getstructoffset());
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__G__Geom1_137_8_6(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_138_4_0(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_138_5_0(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_138_6_0(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_138_7_0(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_138_8_0(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_138_9_0(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_138_0_1(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_138_1_1(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_138_2_1(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_138_3_1(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_138_4_1(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_138_5_1(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_138_6_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((const TGeoMatrix*)(G__getstructoffset()))->GetHomogenousMatrix((Double_t*)G__int(libp->para[0]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_138_7_1(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_138_8_1(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_138_9_1(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_138_0_2(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_138_1_2(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_138_2_2(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_138_3_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((const TGeoMatrix*)(G__getstructoffset()))->LocalToMaster((const 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_138_4_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((const TGeoMatrix*)(G__getstructoffset()))->LocalToMasterVect((const 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_138_5_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((const TGeoMatrix*)(G__getstructoffset()))->LocalToMasterBomb((const 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_138_6_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((const TGeoMatrix*)(G__getstructoffset()))->MasterToLocal((const 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_138_7_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((const TGeoMatrix*)(G__getstructoffset()))->MasterToLocalVect((const 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_138_8_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((const TGeoMatrix*)(G__getstructoffset()))->MasterToLocalBomb((const 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_138_9_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   switch(libp->paran) {
   case 1:
      G__setnull(result7);
      ((const TGeoMatrix*)(G__getstructoffset()))->Print((Option_t*)G__int(libp->para[0]));
      break;
   case 0:
      G__setnull(result7);
      ((const TGeoMatrix*)(G__getstructoffset()))->Print();
      break;
   }
   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__setnull(result7);
      ((TGeoMatrix*)(G__getstructoffset()))->RotateX((Double_t)G__double(libp->para[0]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_138_1_3(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoMatrix*)(G__getstructoffset()))->RotateY((Double_t)G__double(libp->para[0]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_138_2_3(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoMatrix*)(G__getstructoffset()))->RotateZ((Double_t)G__double(libp->para[0]));
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

static int G__G__Geom1_138_5_3(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_138_6_3(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_138_7_3(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_138_8_3(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      TGeoMatrix::Dictionary();
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_138_9_3(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   G__letint(result7,85,(long)((const TGeoMatrix*)(G__getstructoffset()))->IsA());
   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__setnull(result7);
      ((TGeoMatrix*)(G__getstructoffset()))->ShowMembers(*(TMemberInspector*)libp->para[0].ref,(char*)G__int(libp->para[1]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_138_1_4(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoMatrix*)(G__getstructoffset()))->Streamer(*(TBuffer*)libp->para[0].ref);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_138_2_4(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoMatrix*)(G__getstructoffset()))->StreamerNVirtual(*(TBuffer*)libp->para[0].ref);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_138_3_4(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_138_4_4(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_138_5_4(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_138_6_4(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_138_7_4(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   if(0==G__getstructoffset()) return(1);
   if(G__getaryconstruct())
     if(G__PVOID==G__getgvp())
       delete[] (TGeoMatrix *)(G__getstructoffset());
     else
       for(int i=G__getaryconstruct()-1;i>=0;i--)
         delete (TGeoMatrix *)((G__getstructoffset())+sizeof(TGeoMatrix)*i);
   else  delete (TGeoMatrix *)(G__getstructoffset());
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGeoHMatrix */
static int G__G__Geom1_139_1_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   TGeoHMatrix *p=NULL;
   if(G__getaryconstruct()) p=new TGeoHMatrix[G__getaryconstruct()];
   else                    p=new TGeoHMatrix;
      result7->obj.i = (long)p;
      result7->ref = (long)p;
      result7->type = 'u';
      result7->tagnum = G__get_linked_tagnum(&G__G__Geom1LN_TGeoHMatrix);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_139_2_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   TGeoHMatrix *p=NULL;
      p = new TGeoHMatrix(*(TGeoMatrix*)libp->para[0].ref);
      result7->obj.i = (long)p;
      result7->ref = (long)p;
      result7->type = 'u';
      result7->tagnum = G__get_linked_tagnum(&G__G__Geom1LN_TGeoHMatrix);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_139_3_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   TGeoHMatrix *p=NULL;
      p = new TGeoHMatrix((const char*)G__int(libp->para[0]));
      result7->obj.i = (long)p;
      result7->ref = (long)p;
      result7->type = 'u';
      result7->tagnum = G__get_linked_tagnum(&G__G__Geom1LN_TGeoHMatrix);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_139_4_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      {
        const TGeoHMatrix& obj=((TGeoHMatrix*)(G__getstructoffset()))->operator=((const 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_139_5_0(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_139_6_0(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_139_7_0(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_139_8_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   switch(libp->paran) {
   case 1:
      G__setnull(result7);
      ((TGeoHMatrix*)(G__getstructoffset()))->Clear((Option_t*)G__int(libp->para[0]));
      break;
   case 0:
      G__setnull(result7);
      ((TGeoHMatrix*)(G__getstructoffset()))->Clear();
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_139_9_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      {
        const TGeoMatrix& obj=((const TGeoHMatrix*)(G__getstructoffset()))->Inverse();
         result7->ref=(long)(&obj); result7->obj.i=(long)(&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_139_0_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoHMatrix*)(G__getstructoffset()))->Multiply((const TGeoMatrix*)G__int(libp->para[0]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_139_1_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoHMatrix*)(G__getstructoffset()))->MultiplyLeft((const TGeoMatrix*)G__int(libp->para[0]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_139_2_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoHMatrix*)(G__getstructoffset()))->RotateX((Double_t)G__double(libp->para[0]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_139_3_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoHMatrix*)(G__getstructoffset()))->RotateY((Double_t)G__double(libp->para[0]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_139_4_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoHMatrix*)(G__getstructoffset()))->RotateZ((Double_t)G__double(libp->para[0]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_139_5_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoHMatrix*)(G__getstructoffset()))->SavePrimitive(*(ofstream*)libp->para[0].ref,(Option_t*)G__int(libp->para[1]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_139_6_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoHMatrix*)(G__getstructoffset()))->SetTranslation((const Double_t*)G__int(libp->para[0]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_139_7_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoHMatrix*)(G__getstructoffset()))->SetRotation((const Double_t*)G__int(libp->para[0]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_139_8_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoHMatrix*)(G__getstructoffset()))->SetScale((const Double_t*)G__int(libp->para[0]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_139_9_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   G__letint(result7,68,(long)((const TGeoHMatrix*)(G__getstructoffset()))->GetTranslation());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_139_0_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   G__letint(result7,68,(long)((const TGeoHMatrix*)(G__getstructoffset()))->GetRotationMatrix());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_139_1_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   G__letint(result7,68,(long)((const TGeoHMatrix*)(G__getstructoffset()))->GetScale());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_139_2_2(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_139_3_2(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_139_4_2(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_139_5_2(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_139_6_2(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_139_7_2(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_139_8_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      TGeoHMatrix::Dictionary();
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__Geom1_139_0_3(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoHMatrix*)(G__getstructoffset()))->ShowMembers(*(TMemberInspector*)libp->para[0].ref,(char*)G__int(libp->para[1]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_139_1_3(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoHMatrix*)(G__getstructoffset()))->Streamer(*(TBuffer*)libp->para[0].ref);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_139_2_3(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoHMatrix*)(G__getstructoffset()))->StreamerNVirtual(*(TBuffer*)libp->para[0].ref);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_139_3_3(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_139_4_3(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_139_5_3(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_139_6_3(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_139_7_3(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash)
{
   TGeoHMatrix *p;
   void *xtmp = (void*)G__int(libp->para[0]);
   p=new TGeoHMatrix(*(TGeoHMatrix*)xtmp);
   result7->obj.i = (long)p;
   result7->ref = (long)p;
   result7->type = 'u';
   result7->tagnum = 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_139_8_3(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   if(0==G__getstructoffset()) return(1);
   if(G__getaryconstruct())
     if(G__PVOID==G__getgvp())
       delete[] (TGeoHMatrix *)(G__getstructoffset());
     else
       for(int i=G__getaryconstruct()-1;i>=0;i--)
         delete (TGeoHMatrix *)((G__getstructoffset())+sizeof(TGeoHMatrix)*i);
   else  delete (TGeoHMatrix *)(G__getstructoffset());
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGeoBoolNode */
static int G__G__Geom1_140_5_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((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]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_140_6_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((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]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_140_7_0(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_140_8_0(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_140_9_0(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_140_0_1(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_140_1_1(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_140_2_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__letint(result7,105,(long)((const TGeoBoolNode*)(G__getstructoffset()))->GetNpoints());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_140_3_1(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_140_4_1(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_140_5_1(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_140_6_1(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_140_7_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoBoolNode*)(G__getstructoffset()))->Paint((Option_t*)G__int(libp->para[0]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_140_8_1(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_140_9_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((const TGeoBoolNode*)(G__getstructoffset()))->SetPoints((Double_t*)G__int(libp->para[0]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_140_0_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((const TGeoBoolNode*)(G__getstructoffset()))->SetPoints((Float_t*)G__int(libp->para[0]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_140_1_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoBoolNode*)(G__getstructoffset()))->SetSelected((Int_t)G__int(libp->para[0]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_140_2_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((const TGeoBoolNode*)(G__getstructoffset()))->Sizeof3D();
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_140_3_2(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_140_4_2(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_140_5_2(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_140_6_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      TGeoBoolNode::Dictionary();
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__Geom1_140_8_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoBoolNode*)(G__getstructoffset()))->ShowMembers(*(TMemberInspector*)libp->para[0].ref,(char*)G__int(libp->para[1]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_140_9_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoBoolNode*)(G__getstructoffset()))->Streamer(*(TBuffer*)libp->para[0].ref);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_140_0_3(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoBoolNode*)(G__getstructoffset()))->StreamerNVirtual(*(TBuffer*)libp->para[0].ref);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_140_1_3(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_140_2_3(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_140_3_3(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_140_4_3(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_140_5_3(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   if(0==G__getstructoffset()) return(1);
   if(G__getaryconstruct())
     if(G__PVOID==G__getgvp())
       delete[] (TGeoBoolNode *)(G__getstructoffset());
     else
       for(int i=G__getaryconstruct()-1;i>=0;i--)
         delete (TGeoBoolNode *)((G__getstructoffset())+sizeof(TGeoBoolNode)*i);
   else  delete (TGeoBoolNode *)(G__getstructoffset());
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__G__Geom1_140_6_3(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   TGeoBoolNode *dest = (TGeoBoolNode*)(G__getstructoffset());
   *dest = (*(TGeoBoolNode*)libp->para[0].ref);
   const TGeoBoolNode& obj = *dest;
   result7->ref=(long)(&obj); result7->obj.i=(long)(&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGeoUnion */
static int G__G__Geom1_142_1_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   TGeoUnion *p=NULL;
   if(G__getaryconstruct()) p=new TGeoUnion[G__getaryconstruct()];
   else                    p=new TGeoUnion;
      result7->obj.i = (long)p;
      result7->ref = (long)p;
      result7->type = 'u';
      result7->tagnum = G__get_linked_tagnum(&G__G__Geom1LN_TGeoUnion);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_142_2_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   TGeoUnion *p=NULL;
      p = new TGeoUnion((const char*)G__int(libp->para[0]),(const char*)G__int(libp->para[1]));
      result7->obj.i = (long)p;
      result7->ref = (long)p;
      result7->type = 'u';
      result7->tagnum = G__get_linked_tagnum(&G__G__Geom1LN_TGeoUnion);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_142_3_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   TGeoUnion *p=NULL;
   switch(libp->paran) {
   case 4:
      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]));
      break;
   case 3:
      p = new TGeoUnion(
(TGeoShape*)G__int(libp->para[0]),(TGeoShape*)G__int(libp->para[1])
,(TGeoMatrix*)G__int(libp->para[2]));
      break;
   case 2:
      p = new TGeoUnion((TGeoShape*)G__int(libp->para[0]),(TGeoShape*)G__int(libp->para[1]));
      break;
   }
      result7->obj.i = (long)p;
      result7->ref = (long)p;
      result7->type = 'u';
      result7->tagnum = G__get_linked_tagnum(&G__G__Geom1LN_TGeoUnion);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_142_4_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoUnion*)(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]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_142_5_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoUnion*)(G__getstructoffset()))->ComputeNormal((Double_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_142_6_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__letint(result7,103,(long)((const TGeoUnion*)(G__getstructoffset()))->Contains((Double_t*)G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_142_7_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__letint(result7,105,(long)((TGeoUnion*)(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_142_8_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   switch(libp->paran) {
   case 5:
      G__letdouble(result7,100,(double)((const TGeoUnion*)(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 TGeoUnion*)(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 TGeoUnion*)(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 TGeoUnion*)(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_142_9_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   switch(libp->paran) {
   case 5:
      G__letdouble(result7,100,(double)((const TGeoUnion*)(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 TGeoUnion*)(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 TGeoUnion*)(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 TGeoUnion*)(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_142_0_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__letint(result7,105,(long)((const TGeoUnion*)(G__getstructoffset()))->GetBooleanOperator());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_142_1_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__letint(result7,105,(long)((const TGeoUnion*)(G__getstructoffset()))->GetNpoints());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_142_2_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   switch(libp->paran) {
   case 2:
      G__letdouble(result7,100,(double)((const TGeoUnion*)(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 TGeoUnion*)(G__getstructoffset()))->Safety((Double_t*)G__int(libp->para[0])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_142_3_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((const TGeoUnion*)(G__getstructoffset()))->SetPoints((Double_t*)G__int(libp->para[0]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_142_4_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((const TGeoUnion*)(G__getstructoffset()))->SetPoints((Float_t*)G__int(libp->para[0]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_142_5_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((const TGeoUnion*)(G__getstructoffset()))->Sizeof3D();
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_142_6_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoUnion*)(G__getstructoffset()))->Paint((Option_t*)G__int(libp->para[0]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_142_7_1(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_142_8_1(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_142_9_1(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_142_0_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      TGeoUnion::Dictionary();
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__Geom1_142_2_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoUnion*)(G__getstructoffset()))->ShowMembers(*(TMemberInspector*)libp->para[0].ref,(char*)G__int(libp->para[1]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_142_3_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoUnion*)(G__getstructoffset()))->Streamer(*(TBuffer*)libp->para[0].ref);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_142_4_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoUnion*)(G__getstructoffset()))->StreamerNVirtual(*(TBuffer*)libp->para[0].ref);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_142_5_2(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_142_6_2(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_142_7_2(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_142_8_2(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 copy constructor
static int G__G__Geom1_142_9_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash)
{
   TGeoUnion *p;
   void *xtmp = (void*)G__int(libp->para[0]);
   p=new TGeoUnion(*(TGeoUnion*)xtmp);
   result7->obj.i = (long)p;
   result7->ref = (long)p;
   result7->type = 'u';
   result7->tagnum = G__get_linked_tagnum(&G__G__Geom1LN_TGeoUnion);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGeoUnion G__TTGeoUnion;
static int G__G__Geom1_142_0_3(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   if(0==G__getstructoffset()) return(1);
   if(G__getaryconstruct())
     if(G__PVOID==G__getgvp())
       delete[] (TGeoUnion *)(G__getstructoffset());
     else
       for(int i=G__getaryconstruct()-1;i>=0;i--)
         delete (TGeoUnion *)((G__getstructoffset())+sizeof(TGeoUnion)*i);
   else  delete (TGeoUnion *)(G__getstructoffset());
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__G__Geom1_142_1_3(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   TGeoUnion *dest = (TGeoUnion*)(G__getstructoffset());
   *dest = (*(TGeoUnion*)libp->para[0].ref);
   const TGeoUnion& obj = *dest;
   result7->ref=(long)(&obj); result7->obj.i=(long)(&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGeoIntersection */
static int G__G__Geom1_143_1_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   TGeoIntersection *p=NULL;
   if(G__getaryconstruct()) p=new TGeoIntersection[G__getaryconstruct()];
   else                    p=new TGeoIntersection;
      result7->obj.i = (long)p;
      result7->ref = (long)p;
      result7->type = 'u';
      result7->tagnum = G__get_linked_tagnum(&G__G__Geom1LN_TGeoIntersection);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_143_2_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   TGeoIntersection *p=NULL;
      p = new TGeoIntersection((const char*)G__int(libp->para[0]),(const char*)G__int(libp->para[1]));
      result7->obj.i = (long)p;
      result7->ref = (long)p;
      result7->type = 'u';
      result7->tagnum = G__get_linked_tagnum(&G__G__Geom1LN_TGeoIntersection);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_143_3_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   TGeoIntersection *p=NULL;
   switch(libp->paran) {
   case 4:
      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]));
      break;
   case 3:
      p = new TGeoIntersection(
(TGeoShape*)G__int(libp->para[0]),(TGeoShape*)G__int(libp->para[1])
,(TGeoMatrix*)G__int(libp->para[2]));
      break;
   case 2:
      p = new TGeoIntersection((TGeoShape*)G__int(libp->para[0]),(TGeoShape*)G__int(libp->para[1]));
      break;
   }
      result7->obj.i = (long)p;
      result7->ref = (long)p;
      result7->type = 'u';
      result7->tagnum = G__get_linked_tagnum(&G__G__Geom1LN_TGeoIntersection);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_143_4_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoIntersection*)(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]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_143_5_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoIntersection*)(G__getstructoffset()))->ComputeNormal((Double_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_143_6_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__letint(result7,103,(long)((const TGeoIntersection*)(G__getstructoffset()))->Contains((Double_t*)G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_143_7_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__letint(result7,105,(long)((TGeoIntersection*)(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_143_8_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   switch(libp->paran) {
   case 5:
      G__letdouble(result7,100,(double)((const TGeoIntersection*)(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 TGeoIntersection*)(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 TGeoIntersection*)(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 TGeoIntersection*)(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_143_9_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   switch(libp->paran) {
   case 5:
      G__letdouble(result7,100,(double)((const TGeoIntersection*)(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 TGeoIntersection*)(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 TGeoIntersection*)(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 TGeoIntersection*)(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_143_0_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__letint(result7,105,(long)((const TGeoIntersection*)(G__getstructoffset()))->GetBooleanOperator());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_143_1_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__letint(result7,105,(long)((const TGeoIntersection*)(G__getstructoffset()))->GetNpoints());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_143_2_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   switch(libp->paran) {
   case 2:
      G__letdouble(result7,100,(double)((const TGeoIntersection*)(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 TGeoIntersection*)(G__getstructoffset()))->Safety((Double_t*)G__int(libp->para[0])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_143_3_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((const TGeoIntersection*)(G__getstructoffset()))->SetPoints((Double_t*)G__int(libp->para[0]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_143_4_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((const TGeoIntersection*)(G__getstructoffset()))->SetPoints((Float_t*)G__int(libp->para[0]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_143_5_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((const TGeoIntersection*)(G__getstructoffset()))->Sizeof3D();
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_143_6_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoIntersection*)(G__getstructoffset()))->Paint((Option_t*)G__int(libp->para[0]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_143_7_1(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_143_8_1(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_143_9_1(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_143_0_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      TGeoIntersection::Dictionary();
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__Geom1_143_2_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoIntersection*)(G__getstructoffset()))->ShowMembers(*(TMemberInspector*)libp->para[0].ref,(char*)G__int(libp->para[1]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_143_3_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoIntersection*)(G__getstructoffset()))->Streamer(*(TBuffer*)libp->para[0].ref);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_143_4_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoIntersection*)(G__getstructoffset()))->StreamerNVirtual(*(TBuffer*)libp->para[0].ref);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_143_5_2(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_143_6_2(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_143_7_2(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_143_8_2(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 copy constructor
static int G__G__Geom1_143_9_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash)
{
   TGeoIntersection *p;
   void *xtmp = (void*)G__int(libp->para[0]);
   p=new TGeoIntersection(*(TGeoIntersection*)xtmp);
   result7->obj.i = (long)p;
   result7->ref = (long)p;
   result7->type = 'u';
   result7->tagnum = G__get_linked_tagnum(&G__G__Geom1LN_TGeoIntersection);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGeoIntersection G__TTGeoIntersection;
static int G__G__Geom1_143_0_3(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   if(0==G__getstructoffset()) return(1);
   if(G__getaryconstruct())
     if(G__PVOID==G__getgvp())
       delete[] (TGeoIntersection *)(G__getstructoffset());
     else
       for(int i=G__getaryconstruct()-1;i>=0;i--)
         delete (TGeoIntersection *)((G__getstructoffset())+sizeof(TGeoIntersection)*i);
   else  delete (TGeoIntersection *)(G__getstructoffset());
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__G__Geom1_143_1_3(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   TGeoIntersection *dest = (TGeoIntersection*)(G__getstructoffset());
   *dest = (*(TGeoIntersection*)libp->para[0].ref);
   const TGeoIntersection& obj = *dest;
   result7->ref=(long)(&obj); result7->obj.i=(long)(&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGeoSubtraction */
static int G__G__Geom1_144_1_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   TGeoSubtraction *p=NULL;
   if(G__getaryconstruct()) p=new TGeoSubtraction[G__getaryconstruct()];
   else                    p=new TGeoSubtraction;
      result7->obj.i = (long)p;
      result7->ref = (long)p;
      result7->type = 'u';
      result7->tagnum = G__get_linked_tagnum(&G__G__Geom1LN_TGeoSubtraction);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_144_2_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   TGeoSubtraction *p=NULL;
      p = new TGeoSubtraction((const char*)G__int(libp->para[0]),(const char*)G__int(libp->para[1]));
      result7->obj.i = (long)p;
      result7->ref = (long)p;
      result7->type = 'u';
      result7->tagnum = G__get_linked_tagnum(&G__G__Geom1LN_TGeoSubtraction);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_144_3_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   TGeoSubtraction *p=NULL;
   switch(libp->paran) {
   case 4:
      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]));
      break;
   case 3:
      p = new TGeoSubtraction(
(TGeoShape*)G__int(libp->para[0]),(TGeoShape*)G__int(libp->para[1])
,(TGeoMatrix*)G__int(libp->para[2]));
      break;
   case 2:
      p = new TGeoSubtraction((TGeoShape*)G__int(libp->para[0]),(TGeoShape*)G__int(libp->para[1]));
      break;
   }
      result7->obj.i = (long)p;
      result7->ref = (long)p;
      result7->type = 'u';
      result7->tagnum = G__get_linked_tagnum(&G__G__Geom1LN_TGeoSubtraction);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_144_4_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoSubtraction*)(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]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_144_5_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoSubtraction*)(G__getstructoffset()))->ComputeNormal((Double_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_144_6_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__letint(result7,103,(long)((const TGeoSubtraction*)(G__getstructoffset()))->Contains((Double_t*)G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_144_7_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__letint(result7,105,(long)((TGeoSubtraction*)(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_144_8_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   switch(libp->paran) {
   case 5:
      G__letdouble(result7,100,(double)((const TGeoSubtraction*)(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 TGeoSubtraction*)(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 TGeoSubtraction*)(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 TGeoSubtraction*)(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_144_9_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   switch(libp->paran) {
   case 5:
      G__letdouble(result7,100,(double)((const TGeoSubtraction*)(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 TGeoSubtraction*)(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 TGeoSubtraction*)(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 TGeoSubtraction*)(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_144_0_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__letint(result7,105,(long)((const TGeoSubtraction*)(G__getstructoffset()))->GetBooleanOperator());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_144_1_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__letint(result7,105,(long)((const TGeoSubtraction*)(G__getstructoffset()))->GetNpoints());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_144_2_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   switch(libp->paran) {
   case 2:
      G__letdouble(result7,100,(double)((const TGeoSubtraction*)(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 TGeoSubtraction*)(G__getstructoffset()))->Safety((Double_t*)G__int(libp->para[0])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_144_3_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((const TGeoSubtraction*)(G__getstructoffset()))->SetPoints((Double_t*)G__int(libp->para[0]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_144_4_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((const TGeoSubtraction*)(G__getstructoffset()))->SetPoints((Float_t*)G__int(libp->para[0]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_144_5_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((const TGeoSubtraction*)(G__getstructoffset()))->Sizeof3D();
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_144_6_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoSubtraction*)(G__getstructoffset()))->Paint((Option_t*)G__int(libp->para[0]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_144_7_1(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_144_8_1(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_144_9_1(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_144_0_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      TGeoSubtraction::Dictionary();
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__Geom1_144_2_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoSubtraction*)(G__getstructoffset()))->ShowMembers(*(TMemberInspector*)libp->para[0].ref,(char*)G__int(libp->para[1]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_144_3_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoSubtraction*)(G__getstructoffset()))->Streamer(*(TBuffer*)libp->para[0].ref);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_144_4_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoSubtraction*)(G__getstructoffset()))->StreamerNVirtual(*(TBuffer*)libp->para[0].ref);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_144_5_2(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_144_6_2(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_144_7_2(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_144_8_2(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 copy constructor
static int G__G__Geom1_144_9_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash)
{
   TGeoSubtraction *p;
   void *xtmp = (void*)G__int(libp->para[0]);
   p=new TGeoSubtraction(*(TGeoSubtraction*)xtmp);
   result7->obj.i = (long)p;
   result7->ref = (long)p;
   result7->type = 'u';
   result7->tagnum = G__get_linked_tagnum(&G__G__Geom1LN_TGeoSubtraction);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGeoSubtraction G__TTGeoSubtraction;
static int G__G__Geom1_144_0_3(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   if(0==G__getstructoffset()) return(1);
   if(G__getaryconstruct())
     if(G__PVOID==G__getgvp())
       delete[] (TGeoSubtraction *)(G__getstructoffset());
     else
       for(int i=G__getaryconstruct()-1;i>=0;i--)
         delete (TGeoSubtraction *)((G__getstructoffset())+sizeof(TGeoSubtraction)*i);
   else  delete (TGeoSubtraction *)(G__getstructoffset());
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__G__Geom1_144_1_3(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   TGeoSubtraction *dest = (TGeoSubtraction*)(G__getstructoffset());
   *dest = (*(TGeoSubtraction*)libp->para[0].ref);
   const TGeoSubtraction& obj = *dest;
   result7->ref=(long)(&obj); result7->obj.i=(long)(&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGeoElementTable */
static int G__G__Geom1_151_2_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   TGeoElementTable *p=NULL;
   if(G__getaryconstruct()) p=new TGeoElementTable[G__getaryconstruct()];
   else                    p=new TGeoElementTable;
      result7->obj.i = (long)p;
      result7->ref = (long)p;
      result7->type = 'u';
      result7->tagnum = G__get_linked_tagnum(&G__G__Geom1LN_TGeoElementTable);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_151_3_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   TGeoElementTable *p=NULL;
      p = new TGeoElementTable((Int_t)G__int(libp->para[0]));
      result7->obj.i = (long)p;
      result7->ref = (long)p;
      result7->type = 'u';
      result7->tagnum = G__get_linked_tagnum(&G__G__Geom1LN_TGeoElementTable);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_151_4_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((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]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_151_5_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   G__letint(result7,85,(long)((TGeoElementTable*)(G__getstructoffset()))->FindElement((const char*)G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_151_6_0(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_151_7_0(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_151_8_0(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_151_9_0(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_151_0_1(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_151_1_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      TGeoElementTable::Dictionary();
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__Geom1_151_3_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoElementTable*)(G__getstructoffset()))->ShowMembers(*(TMemberInspector*)libp->para[0].ref,(char*)G__int(libp->para[1]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_151_4_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoElementTable*)(G__getstructoffset()))->Streamer(*(TBuffer*)libp->para[0].ref);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_151_5_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoElementTable*)(G__getstructoffset()))->StreamerNVirtual(*(TBuffer*)libp->para[0].ref);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_151_6_1(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_151_7_1(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_151_8_1(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_151_9_1(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 copy constructor
static int G__G__Geom1_151_0_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash)
{
   TGeoElementTable *p;
   void *xtmp = (void*)G__int(libp->para[0]);
   p=new TGeoElementTable(*(TGeoElementTable*)xtmp);
   result7->obj.i = (long)p;
   result7->ref = (long)p;
   result7->type = 'u';
   result7->tagnum = G__get_linked_tagnum(&G__G__Geom1LN_TGeoElementTable);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGeoElementTable G__TTGeoElementTable;
static int G__G__Geom1_151_1_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   if(0==G__getstructoffset()) return(1);
   if(G__getaryconstruct())
     if(G__PVOID==G__getgvp())
       delete[] (TGeoElementTable *)(G__getstructoffset());
     else
       for(int i=G__getaryconstruct()-1;i>=0;i--)
         delete (TGeoElementTable *)((G__getstructoffset())+sizeof(TGeoElementTable)*i);
   else  delete (TGeoElementTable *)(G__getstructoffset());
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__G__Geom1_151_2_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   TGeoElementTable *dest = (TGeoElementTable*)(G__getstructoffset());
   *dest = (*(TGeoElementTable*)libp->para[0].ref);
   const TGeoElementTable& obj = *dest;
   result7->ref=(long)(&obj); result7->obj.i=(long)(&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGeoElement */
static int G__G__Geom1_152_1_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   TGeoElement *p=NULL;
   if(G__getaryconstruct()) p=new TGeoElement[G__getaryconstruct()];
   else                    p=new TGeoElement;
      result7->obj.i = (long)p;
      result7->ref = (long)p;
      result7->type = 'u';
      result7->tagnum = G__get_linked_tagnum(&G__G__Geom1LN_TGeoElement);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_152_2_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   TGeoElement *p=NULL;
      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]));
      result7->obj.i = (long)p;
      result7->ref = (long)p;
      result7->type = 'u';
      result7->tagnum = G__get_linked_tagnum(&G__G__Geom1LN_TGeoElement);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_152_3_0(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_152_4_0(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_152_5_0(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_152_6_0(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_152_7_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   switch(libp->paran) {
   case 1:
      G__setnull(result7);
      ((TGeoElement*)(G__getstructoffset()))->SetDefined((Bool_t)G__int(libp->para[0]));
      break;
   case 0:
      G__setnull(result7);
      ((TGeoElement*)(G__getstructoffset()))->SetDefined();
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

static int G__G__Geom1_152_0_1(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_152_1_1(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_152_2_1(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_152_3_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      TGeoElement::Dictionary();
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__Geom1_152_5_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoElement*)(G__getstructoffset()))->ShowMembers(*(TMemberInspector*)libp->para[0].ref,(char*)G__int(libp->para[1]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_152_6_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoElement*)(G__getstructoffset()))->Streamer(*(TBuffer*)libp->para[0].ref);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_152_7_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoElement*)(G__getstructoffset()))->StreamerNVirtual(*(TBuffer*)libp->para[0].ref);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_152_8_1(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_152_9_1(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_152_0_2(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_152_1_2(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 copy constructor
static int G__G__Geom1_152_2_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash)
{
   TGeoElement *p;
   void *xtmp = (void*)G__int(libp->para[0]);
   p=new TGeoElement(*(TGeoElement*)xtmp);
   result7->obj.i = (long)p;
   result7->ref = (long)p;
   result7->type = 'u';
   result7->tagnum = G__get_linked_tagnum(&G__G__Geom1LN_TGeoElement);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGeoElement G__TTGeoElement;
static int G__G__Geom1_152_3_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   if(0==G__getstructoffset()) return(1);
   if(G__getaryconstruct())
     if(G__PVOID==G__getgvp())
       delete[] (TGeoElement *)(G__getstructoffset());
     else
       for(int i=G__getaryconstruct()-1;i>=0;i--)
         delete (TGeoElement *)((G__getstructoffset())+sizeof(TGeoElement)*i);
   else  delete (TGeoElement *)(G__getstructoffset());
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__G__Geom1_152_4_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   TGeoElement *dest = (TGeoElement*)(G__getstructoffset());
   *dest = (*(TGeoElement*)libp->para[0].ref);
   const TGeoElement& obj = *dest;
   result7->ref=(long)(&obj); result7->obj.i=(long)(&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGeoMaterial */
static int G__G__Geom1_154_1_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   TGeoMaterial *p=NULL;
   if(G__getaryconstruct()) p=new TGeoMaterial[G__getaryconstruct()];
   else                    p=new TGeoMaterial;
      result7->obj.i = (long)p;
      result7->ref = (long)p;
      result7->type = 'u';
      result7->tagnum = G__get_linked_tagnum(&G__G__Geom1LN_TGeoMaterial);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_154_2_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   TGeoMaterial *p=NULL;
      p = new TGeoMaterial((const char*)G__int(libp->para[0]));
      result7->obj.i = (long)p;
      result7->ref = (long)p;
      result7->type = 'u';
      result7->tagnum = G__get_linked_tagnum(&G__G__Geom1LN_TGeoMaterial);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_154_3_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   TGeoMaterial *p=NULL;
   switch(libp->paran) {
   case 6:
      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]));
      break;
   case 5:
      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]));
      break;
   case 4:
      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]));
      break;
   }
      result7->obj.i = (long)p;
      result7->ref = (long)p;
      result7->type = 'u';
      result7->tagnum = G__get_linked_tagnum(&G__G__Geom1LN_TGeoMaterial);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_154_4_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   TGeoMaterial *p=NULL;
      p = new 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;
      result7->type = 'u';
      result7->tagnum = G__get_linked_tagnum(&G__G__Geom1LN_TGeoMaterial);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_154_5_0(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_154_6_0(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_154_7_0(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_154_8_0(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_154_9_0(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_154_0_1(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_154_1_1(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_154_2_1(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_154_3_1(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_154_4_1(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_154_5_1(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_154_6_1(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_154_7_1(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_154_8_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__letint(result7,103,(long)((const TGeoMaterial*)(G__getstructoffset()))->IsEq((const TGeoMaterial*)G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_154_9_1(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_154_0_2(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_154_1_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   switch(libp->paran) {
   case 1:
      G__setnull(result7);
      ((const TGeoMaterial*)(G__getstructoffset()))->Print((Option_t*)G__int(libp->para[0]));
      break;
   case 0:
      G__setnull(result7);
      ((const TGeoMaterial*)(G__getstructoffset()))->Print();
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_154_2_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoMaterial*)(G__getstructoffset()))->SavePrimitive(*(ofstream*)libp->para[0].ref,(Option_t*)G__int(libp->para[1]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_154_3_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoMaterial*)(G__getstructoffset()))->SetIndex((Int_t)G__int(libp->para[0]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_154_4_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoMaterial*)(G__getstructoffset()))->SetCerenkovProperties((TObject*)G__int(libp->para[0]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_154_5_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   switch(libp->paran) {
   case 2:
      G__setnull(result7);
      ((TGeoMaterial*)(G__getstructoffset()))->SetRadLen((Double_t)G__double(libp->para[0]),(Double_t)G__double(libp->para[1]));
      break;
   case 1:
      G__setnull(result7);
      ((TGeoMaterial*)(G__getstructoffset()))->SetRadLen((Double_t)G__double(libp->para[0]));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

static int G__G__Geom1_154_8_2(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_154_9_2(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_154_0_3(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_154_1_3(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_154_2_3(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      TGeoMaterial::Dictionary();
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__Geom1_154_4_3(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoMaterial*)(G__getstructoffset()))->ShowMembers(*(TMemberInspector*)libp->para[0].ref,(char*)G__int(libp->para[1]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_154_5_3(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoMaterial*)(G__getstructoffset()))->Streamer(*(TBuffer*)libp->para[0].ref);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_154_6_3(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoMaterial*)(G__getstructoffset()))->StreamerNVirtual(*(TBuffer*)libp->para[0].ref);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_154_7_3(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_154_8_3(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_154_9_3(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_154_0_4(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 copy constructor
static int G__G__Geom1_154_1_4(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash)
{
   TGeoMaterial *p;
   void *xtmp = (void*)G__int(libp->para[0]);
   p=new TGeoMaterial(*(TGeoMaterial*)xtmp);
   result7->obj.i = (long)p;
   result7->ref = (long)p;
   result7->type = 'u';
   result7->tagnum = G__get_linked_tagnum(&G__G__Geom1LN_TGeoMaterial);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGeoMaterial G__TTGeoMaterial;
static int G__G__Geom1_154_2_4(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   if(0==G__getstructoffset()) return(1);
   if(G__getaryconstruct())
     if(G__PVOID==G__getgvp())
       delete[] (TGeoMaterial *)(G__getstructoffset());
     else
       for(int i=G__getaryconstruct()-1;i>=0;i--)
         delete (TGeoMaterial *)((G__getstructoffset())+sizeof(TGeoMaterial)*i);
   else  delete (TGeoMaterial *)(G__getstructoffset());
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__G__Geom1_154_3_4(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   TGeoMaterial *dest = (TGeoMaterial*)(G__getstructoffset());
   *dest = (*(TGeoMaterial*)libp->para[0].ref);
   const TGeoMaterial& obj = *dest;
   result7->ref=(long)(&obj); result7->obj.i=(long)(&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGeoMixture */
static int G__G__Geom1_156_1_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   TGeoMixture *p=NULL;
   if(G__getaryconstruct()) p=new TGeoMixture[G__getaryconstruct()];
   else                    p=new TGeoMixture;
      result7->obj.i = (long)p;
      result7->ref = (long)p;
      result7->type = 'u';
      result7->tagnum = G__get_linked_tagnum(&G__G__Geom1LN_TGeoMixture);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_156_2_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   TGeoMixture *p=NULL;
   switch(libp->paran) {
   case 3:
      p = new 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:
      p = new 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;
      result7->type = 'u';
      result7->tagnum = G__get_linked_tagnum(&G__G__Geom1LN_TGeoMixture);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_156_3_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((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]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_156_4_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoMixture*)(G__getstructoffset()))->DefineElement((Int_t)G__int(libp->para[0]),(TGeoElement*)G__int(libp->para[1])
,(Double_t)G__double(libp->para[2]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_156_5_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((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]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_156_6_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__letint(result7,105,(long)((const TGeoMixture*)(G__getstructoffset()))->GetByteCount());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_156_7_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   switch(libp->paran) {
   case 1:
   G__letint(result7,85,(long)((const TGeoMixture*)(G__getstructoffset()))->GetElement((Int_t)G__int(libp->para[0])));
      break;
   case 0:
   G__letint(result7,85,(long)((const TGeoMixture*)(G__getstructoffset()))->GetElement());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_156_8_0(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_156_9_0(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_156_0_1(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_156_1_1(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_156_2_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__letint(result7,103,(long)((const TGeoMixture*)(G__getstructoffset()))->IsEq((const TGeoMaterial*)G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_156_3_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__letint(result7,103,(long)((const TGeoMixture*)(G__getstructoffset()))->IsMixture());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_156_4_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   switch(libp->paran) {
   case 1:
      G__setnull(result7);
      ((const TGeoMixture*)(G__getstructoffset()))->Print((Option_t*)G__int(libp->para[0]));
      break;
   case 0:
      G__setnull(result7);
      ((const TGeoMixture*)(G__getstructoffset()))->Print();
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_156_5_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoMixture*)(G__getstructoffset()))->SavePrimitive(*(ofstream*)libp->para[0].ref,(Option_t*)G__int(libp->para[1]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_156_6_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoMixture*)(G__getstructoffset()))->SetA((Double_t)G__double(libp->para[0]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_156_7_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoMixture*)(G__getstructoffset()))->SetZ((Double_t)G__double(libp->para[0]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_156_8_1(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_156_9_1(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_156_0_2(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_156_1_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      TGeoMixture::Dictionary();
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__Geom1_156_3_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoMixture*)(G__getstructoffset()))->ShowMembers(*(TMemberInspector*)libp->para[0].ref,(char*)G__int(libp->para[1]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_156_4_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoMixture*)(G__getstructoffset()))->Streamer(*(TBuffer*)libp->para[0].ref);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_156_5_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoMixture*)(G__getstructoffset()))->StreamerNVirtual(*(TBuffer*)libp->para[0].ref);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_156_6_2(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_156_7_2(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_156_8_2(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_156_9_2(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 copy constructor
static int G__G__Geom1_156_0_3(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash)
{
   TGeoMixture *p;
   void *xtmp = (void*)G__int(libp->para[0]);
   p=new TGeoMixture(*(TGeoMixture*)xtmp);
   result7->obj.i = (long)p;
   result7->ref = (long)p;
   result7->type = 'u';
   result7->tagnum = G__get_linked_tagnum(&G__G__Geom1LN_TGeoMixture);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGeoMixture G__TTGeoMixture;
static int G__G__Geom1_156_1_3(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   if(0==G__getstructoffset()) return(1);
   if(G__getaryconstruct())
     if(G__PVOID==G__getgvp())
       delete[] (TGeoMixture *)(G__getstructoffset());
     else
       for(int i=G__getaryconstruct()-1;i>=0;i--)
         delete (TGeoMixture *)((G__getstructoffset())+sizeof(TGeoMixture)*i);
   else  delete (TGeoMixture *)(G__getstructoffset());
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__G__Geom1_156_2_3(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   TGeoMixture *dest = (TGeoMixture*)(G__getstructoffset());
   *dest = (*(TGeoMixture*)libp->para[0].ref);
   const TGeoMixture& obj = *dest;
   result7->ref=(long)(&obj); result7->obj.i=(long)(&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGeoMedium */
static int G__G__Geom1_157_1_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   TGeoMedium *p=NULL;
   if(G__getaryconstruct()) p=new TGeoMedium[G__getaryconstruct()];
   else                    p=new TGeoMedium;
      result7->obj.i = (long)p;
      result7->ref = (long)p;
      result7->type = 'u';
      result7->tagnum = G__get_linked_tagnum(&G__G__Geom1LN_TGeoMedium);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_157_2_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   TGeoMedium *p=NULL;
   switch(libp->paran) {
   case 4:
      p = new TGeoMedium(
(const char*)G__int(libp->para[0]),(Int_t)G__int(libp->para[1])
,(const TGeoMaterial*)G__int(libp->para[2]),(Double_t*)G__int(libp->para[3]));
      break;
   case 3:
      p = new TGeoMedium(
(const char*)G__int(libp->para[0]),(Int_t)G__int(libp->para[1])
,(const TGeoMaterial*)G__int(libp->para[2]));
      break;
   }
      result7->obj.i = (long)p;
      result7->ref = (long)p;
      result7->type = 'u';
      result7->tagnum = G__get_linked_tagnum(&G__G__Geom1LN_TGeoMedium);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_157_3_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   TGeoMedium *p=NULL;
      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]));
      result7->obj.i = (long)p;
      result7->ref = (long)p;
      result7->type = 'u';
      result7->tagnum = G__get_linked_tagnum(&G__G__Geom1LN_TGeoMedium);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_157_4_0(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_157_5_0(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_157_6_0(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_157_7_0(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_157_8_0(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_157_9_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoMedium*)(G__getstructoffset()))->SavePrimitive(*(ofstream*)libp->para[0].ref,(Option_t*)G__int(libp->para[1]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_157_0_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoMedium*)(G__getstructoffset()))->SetId((Int_t)G__int(libp->para[0]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_157_1_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoMedium*)(G__getstructoffset()))->SetMaterial((TGeoMaterial*)G__int(libp->para[0]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_157_2_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoMedium*)(G__getstructoffset()))->SetCerenkovProperties((TObject*)G__int(libp->para[0]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_157_3_1(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_157_4_1(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_157_5_1(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_157_6_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      TGeoMedium::Dictionary();
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__Geom1_157_8_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoMedium*)(G__getstructoffset()))->ShowMembers(*(TMemberInspector*)libp->para[0].ref,(char*)G__int(libp->para[1]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_157_9_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoMedium*)(G__getstructoffset()))->Streamer(*(TBuffer*)libp->para[0].ref);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_157_0_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoMedium*)(G__getstructoffset()))->StreamerNVirtual(*(TBuffer*)libp->para[0].ref);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_157_1_2(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_157_2_2(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_157_3_2(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_157_4_2(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 copy constructor
static int G__G__Geom1_157_5_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash)
{
   TGeoMedium *p;
   void *xtmp = (void*)G__int(libp->para[0]);
   p=new TGeoMedium(*(TGeoMedium*)xtmp);
   result7->obj.i = (long)p;
   result7->ref = (long)p;
   result7->type = 'u';
   result7->tagnum = G__get_linked_tagnum(&G__G__Geom1LN_TGeoMedium);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGeoMedium G__TTGeoMedium;
static int G__G__Geom1_157_6_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   if(0==G__getstructoffset()) return(1);
   if(G__getaryconstruct())
     if(G__PVOID==G__getgvp())
       delete[] (TGeoMedium *)(G__getstructoffset());
     else
       for(int i=G__getaryconstruct()-1;i>=0;i--)
         delete (TGeoMedium *)((G__getstructoffset())+sizeof(TGeoMedium)*i);
   else  delete (TGeoMedium *)(G__getstructoffset());
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__G__Geom1_157_7_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   TGeoMedium *dest = (TGeoMedium*)(G__getstructoffset());
   *dest = (*(TGeoMedium*)libp->para[0].ref);
   const TGeoMedium& obj = *dest;
   result7->ref=(long)(&obj); result7->obj.i=(long)(&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGeoTranslation */
static int G__G__Geom1_160_1_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   TGeoTranslation *p=NULL;
   if(G__getaryconstruct()) p=new TGeoTranslation[G__getaryconstruct()];
   else                    p=new TGeoTranslation;
      result7->obj.i = (long)p;
      result7->ref = (long)p;
      result7->type = 'u';
      result7->tagnum = G__get_linked_tagnum(&G__G__Geom1LN_TGeoTranslation);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_160_2_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   TGeoTranslation *p=NULL;
      p = new TGeoTranslation(*(TGeoTranslation*)libp->para[0].ref);
      result7->obj.i = (long)p;
      result7->ref = (long)p;
      result7->type = 'u';
      result7->tagnum = G__get_linked_tagnum(&G__G__Geom1LN_TGeoTranslation);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_160_3_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   TGeoTranslation *p=NULL;
      p = new TGeoTranslation(*(TGeoMatrix*)libp->para[0].ref);
      result7->obj.i = (long)p;
      result7->ref = (long)p;
      result7->type = 'u';
      result7->tagnum = G__get_linked_tagnum(&G__G__Geom1LN_TGeoTranslation);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_160_4_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   TGeoTranslation *p=NULL;
      p = new 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;
      result7->type = 'u';
      result7->tagnum = G__get_linked_tagnum(&G__G__Geom1LN_TGeoTranslation);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_160_5_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   TGeoTranslation *p=NULL;
      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]));
      result7->obj.i = (long)p;
      result7->ref = (long)p;
      result7->type = 'u';
      result7->tagnum = G__get_linked_tagnum(&G__G__Geom1LN_TGeoTranslation);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_160_6_0(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_160_7_0(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_160_8_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoTranslation*)(G__getstructoffset()))->Add((const TGeoTranslation*)G__int(libp->para[0]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_160_9_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      {
        const TGeoMatrix& obj=((const TGeoTranslation*)(G__getstructoffset()))->Inverse();
         result7->ref=(long)(&obj); result7->obj.i=(long)(&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_160_0_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((const TGeoTranslation*)(G__getstructoffset()))->LocalToMaster((const 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_160_1_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((const TGeoTranslation*)(G__getstructoffset()))->LocalToMasterVect((const 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_160_2_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((const TGeoTranslation*)(G__getstructoffset()))->MasterToLocal((const 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_160_3_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((const TGeoTranslation*)(G__getstructoffset()))->MasterToLocalVect((const 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_160_4_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((const TGeoTranslation*)(G__getstructoffset()))->LocalToMasterBomb((const 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_160_5_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((const TGeoTranslation*)(G__getstructoffset()))->MasterToLocalBomb((const 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_160_6_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoTranslation*)(G__getstructoffset()))->RotateX((Double_t)G__double(libp->para[0]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_160_7_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoTranslation*)(G__getstructoffset()))->RotateY((Double_t)G__double(libp->para[0]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_160_8_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoTranslation*)(G__getstructoffset()))->RotateZ((Double_t)G__double(libp->para[0]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_160_9_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoTranslation*)(G__getstructoffset()))->SavePrimitive(*(ofstream*)libp->para[0].ref,(Option_t*)G__int(libp->para[1]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_160_0_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoTranslation*)(G__getstructoffset()))->Subtract((const TGeoTranslation*)G__int(libp->para[0]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_160_1_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((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]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_160_2_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoTranslation*)(G__getstructoffset()))->SetTranslation(*(TGeoMatrix*)libp->para[0].ref);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_160_3_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoTranslation*)(G__getstructoffset()))->SetDx((Double_t)G__double(libp->para[0]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_160_4_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoTranslation*)(G__getstructoffset()))->SetDy((Double_t)G__double(libp->para[0]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_160_5_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoTranslation*)(G__getstructoffset()))->SetDz((Double_t)G__double(libp->para[0]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_160_6_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   G__letint(result7,68,(long)((const TGeoTranslation*)(G__getstructoffset()))->GetTranslation());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_160_7_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   G__letint(result7,68,(long)((const TGeoTranslation*)(G__getstructoffset()))->GetRotationMatrix());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_160_8_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   G__letint(result7,68,(long)((const TGeoTranslation*)(G__getstructoffset()))->GetScale());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_160_9_2(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_160_0_3(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_160_1_3(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_160_2_3(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      TGeoTranslation::Dictionary();
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__Geom1_160_4_3(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoTranslation*)(G__getstructoffset()))->ShowMembers(*(TMemberInspector*)libp->para[0].ref,(char*)G__int(libp->para[1]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_160_5_3(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoTranslation*)(G__getstructoffset()))->Streamer(*(TBuffer*)libp->para[0].ref);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_160_6_3(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoTranslation*)(G__getstructoffset()))->StreamerNVirtual(*(TBuffer*)libp->para[0].ref);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_160_7_3(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_160_8_3(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_160_9_3(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_160_0_4(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_160_1_4(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   if(0==G__getstructoffset()) return(1);
   if(G__getaryconstruct())
     if(G__PVOID==G__getgvp())
       delete[] (TGeoTranslation *)(G__getstructoffset());
     else
       for(int i=G__getaryconstruct()-1;i>=0;i--)
         delete (TGeoTranslation *)((G__getstructoffset())+sizeof(TGeoTranslation)*i);
   else  delete (TGeoTranslation *)(G__getstructoffset());
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGeoRotation */
static int G__G__Geom1_161_2_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   TGeoRotation *p=NULL;
   if(G__getaryconstruct()) p=new TGeoRotation[G__getaryconstruct()];
   else                    p=new TGeoRotation;
      result7->obj.i = (long)p;
      result7->ref = (long)p;
      result7->type = 'u';
      result7->tagnum = G__get_linked_tagnum(&G__G__Geom1LN_TGeoRotation);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_161_3_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   TGeoRotation *p=NULL;
      p = new TGeoRotation(*(TGeoRotation*)libp->para[0].ref);
      result7->obj.i = (long)p;
      result7->ref = (long)p;
      result7->type = 'u';
      result7->tagnum = G__get_linked_tagnum(&G__G__Geom1LN_TGeoRotation);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_161_4_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   TGeoRotation *p=NULL;
      p = new TGeoRotation(*(TGeoMatrix*)libp->para[0].ref);
      result7->obj.i = (long)p;
      result7->ref = (long)p;
      result7->type = 'u';
      result7->tagnum = G__get_linked_tagnum(&G__G__Geom1LN_TGeoRotation);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_161_5_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   TGeoRotation *p=NULL;
      p = new TGeoRotation((const char*)G__int(libp->para[0]));
      result7->obj.i = (long)p;
      result7->ref = (long)p;
      result7->type = 'u';
      result7->tagnum = G__get_linked_tagnum(&G__G__Geom1LN_TGeoRotation);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_161_6_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   TGeoRotation *p=NULL;
      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]));
      result7->obj.i = (long)p;
      result7->ref = (long)p;
      result7->type = 'u';
      result7->tagnum = G__get_linked_tagnum(&G__G__Geom1LN_TGeoRotation);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_161_7_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   TGeoRotation *p=NULL;
      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]));
      result7->obj.i = (long)p;
      result7->ref = (long)p;
      result7->type = 'u';
      result7->tagnum = G__get_linked_tagnum(&G__G__Geom1LN_TGeoRotation);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_161_8_0(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_161_9_0(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_161_0_1(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_161_1_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      {
        const TGeoMatrix& obj=((const TGeoRotation*)(G__getstructoffset()))->Inverse();
         result7->ref=(long)(&obj); result7->obj.i=(long)(&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__Geom1_161_3_1(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_161_4_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoRotation*)(G__getstructoffset()))->FastRotZ((Double_t*)G__int(libp->para[0]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_161_5_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((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]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_161_6_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__letdouble(result7,100,(double)((const TGeoRotation*)(G__getstructoffset()))->GetPhiRotation());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_161_7_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((const TGeoRotation*)(G__getstructoffset()))->LocalToMaster((const 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_161_8_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((const TGeoRotation*)(G__getstructoffset()))->LocalToMasterVect((const 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_161_9_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((const TGeoRotation*)(G__getstructoffset()))->MasterToLocal((const 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_161_0_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((const TGeoRotation*)(G__getstructoffset()))->MasterToLocalVect((const 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_161_1_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((const TGeoRotation*)(G__getstructoffset()))->LocalToMasterBomb((const 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_161_2_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((const TGeoRotation*)(G__getstructoffset()))->MasterToLocalBomb((const 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_161_3_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   switch(libp->paran) {
   case 2:
      G__setnull(result7);
      ((TGeoRotation*)(G__getstructoffset()))->MultiplyBy((TGeoRotation*)G__int(libp->para[0]),(Bool_t)G__int(libp->para[1]));
      break;
   case 1:
      G__setnull(result7);
      ((TGeoRotation*)(G__getstructoffset()))->MultiplyBy((TGeoRotation*)G__int(libp->para[0]));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_161_4_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoRotation*)(G__getstructoffset()))->RotateX((Double_t)G__double(libp->para[0]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_161_5_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoRotation*)(G__getstructoffset()))->RotateY((Double_t)G__double(libp->para[0]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_161_6_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoRotation*)(G__getstructoffset()))->RotateZ((Double_t)G__double(libp->para[0]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_161_7_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoRotation*)(G__getstructoffset()))->SavePrimitive(*(ofstream*)libp->para[0].ref,(Option_t*)G__int(libp->para[1]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_161_8_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((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]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_161_9_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((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]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_161_0_3(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoRotation*)(G__getstructoffset()))->SetMatrix((const Double_t*)G__int(libp->para[0]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_161_1_3(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoRotation*)(G__getstructoffset()))->SetRotation(*(TGeoMatrix*)libp->para[0].ref);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_161_2_3(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((const TGeoRotation*)(G__getstructoffset()))->GetInverse((Double_t*)G__int(libp->para[0]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_161_3_3(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   G__letint(result7,68,(long)((const TGeoRotation*)(G__getstructoffset()))->GetTranslation());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_161_4_3(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   G__letint(result7,68,(long)((const TGeoRotation*)(G__getstructoffset()))->GetRotationMatrix());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_161_5_3(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   G__letint(result7,68,(long)((const TGeoRotation*)(G__getstructoffset()))->GetScale());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_161_6_3(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_161_7_3(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_161_8_3(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_161_9_3(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      TGeoRotation::Dictionary();
   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) {
   G__letint(result7,85,(long)((const TGeoRotation*)(G__getstructoffset()))->IsA());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_161_1_4(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoRotation*)(G__getstructoffset()))->ShowMembers(*(TMemberInspector*)libp->para[0].ref,(char*)G__int(libp->para[1]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_161_2_4(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoRotation*)(G__getstructoffset()))->Streamer(*(TBuffer*)libp->para[0].ref);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_161_3_4(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoRotation*)(G__getstructoffset()))->StreamerNVirtual(*(TBuffer*)libp->para[0].ref);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_161_4_4(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_161_5_4(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_161_6_4(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_161_7_4(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_161_8_4(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   if(0==G__getstructoffset()) return(1);
   if(G__getaryconstruct())
     if(G__PVOID==G__getgvp())
       delete[] (TGeoRotation *)(G__getstructoffset());
     else
       for(int i=G__getaryconstruct()-1;i>=0;i--)
         delete (TGeoRotation *)((G__getstructoffset())+sizeof(TGeoRotation)*i);
   else  delete (TGeoRotation *)(G__getstructoffset());
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGeoScale */
static int G__G__Geom1_162_1_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   TGeoScale *p=NULL;
   if(G__getaryconstruct()) p=new TGeoScale[G__getaryconstruct()];
   else                    p=new TGeoScale;
      result7->obj.i = (long)p;
      result7->ref = (long)p;
      result7->type = 'u';
      result7->tagnum = G__get_linked_tagnum(&G__G__Geom1LN_TGeoScale);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_162_2_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   TGeoScale *p=NULL;
      p = new TGeoScale(*(TGeoScale*)libp->para[0].ref);
      result7->obj.i = (long)p;
      result7->ref = (long)p;
      result7->type = 'u';
      result7->tagnum = G__get_linked_tagnum(&G__G__Geom1LN_TGeoScale);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_162_3_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   TGeoScale *p=NULL;
      p = new 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;
      result7->type = 'u';
      result7->tagnum = G__get_linked_tagnum(&G__G__Geom1LN_TGeoScale);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_162_4_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   TGeoScale *p=NULL;
      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]));
      result7->obj.i = (long)p;
      result7->ref = (long)p;
      result7->type = 'u';
      result7->tagnum = G__get_linked_tagnum(&G__G__Geom1LN_TGeoScale);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_162_5_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      {
        const TGeoMatrix& obj=((const TGeoScale*)(G__getstructoffset()))->Inverse();
         result7->ref=(long)(&obj); result7->obj.i=(long)(&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_162_6_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((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]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_162_7_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__letint(result7,103,(long)((TGeoScale*)(G__getstructoffset()))->Normalize());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_162_8_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   G__letint(result7,68,(long)((const TGeoScale*)(G__getstructoffset()))->GetTranslation());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_162_9_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   G__letint(result7,68,(long)((const TGeoScale*)(G__getstructoffset()))->GetRotationMatrix());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_162_0_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   G__letint(result7,68,(long)((const TGeoScale*)(G__getstructoffset()))->GetScale());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_162_1_1(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_162_2_1(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_162_3_1(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_162_4_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      TGeoScale::Dictionary();
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__Geom1_162_6_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoScale*)(G__getstructoffset()))->ShowMembers(*(TMemberInspector*)libp->para[0].ref,(char*)G__int(libp->para[1]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_162_7_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoScale*)(G__getstructoffset()))->Streamer(*(TBuffer*)libp->para[0].ref);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_162_8_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoScale*)(G__getstructoffset()))->StreamerNVirtual(*(TBuffer*)libp->para[0].ref);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_162_9_1(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_162_0_2(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_162_1_2(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_162_2_2(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_162_3_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   if(0==G__getstructoffset()) return(1);
   if(G__getaryconstruct())
     if(G__PVOID==G__getgvp())
       delete[] (TGeoScale *)(G__getstructoffset());
     else
       for(int i=G__getaryconstruct()-1;i>=0;i--)
         delete (TGeoScale *)((G__getstructoffset())+sizeof(TGeoScale)*i);
   else  delete (TGeoScale *)(G__getstructoffset());
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__G__Geom1_162_4_2(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_163_1_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   TGeoCombiTrans *p=NULL;
   if(G__getaryconstruct()) p=new TGeoCombiTrans[G__getaryconstruct()];
   else                    p=new TGeoCombiTrans;
      result7->obj.i = (long)p;
      result7->ref = (long)p;
      result7->type = 'u';
      result7->tagnum = G__get_linked_tagnum(&G__G__Geom1LN_TGeoCombiTrans);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_163_2_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   TGeoCombiTrans *p=NULL;
      p = new TGeoCombiTrans(*(TGeoCombiTrans*)libp->para[0].ref);
      result7->obj.i = (long)p;
      result7->ref = (long)p;
      result7->type = 'u';
      result7->tagnum = G__get_linked_tagnum(&G__G__Geom1LN_TGeoCombiTrans);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_163_3_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   TGeoCombiTrans *p=NULL;
      p = new TGeoCombiTrans(*(TGeoMatrix*)libp->para[0].ref);
      result7->obj.i = (long)p;
      result7->ref = (long)p;
      result7->type = 'u';
      result7->tagnum = G__get_linked_tagnum(&G__G__Geom1LN_TGeoCombiTrans);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_163_4_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   TGeoCombiTrans *p=NULL;
      p = new TGeoCombiTrans(*(TGeoTranslation*)libp->para[0].ref,*(TGeoRotation*)libp->para[1].ref);
      result7->obj.i = (long)p;
      result7->ref = (long)p;
      result7->type = 'u';
      result7->tagnum = G__get_linked_tagnum(&G__G__Geom1LN_TGeoCombiTrans);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_163_5_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   TGeoCombiTrans *p=NULL;
      p = new TGeoCombiTrans((const char*)G__int(libp->para[0]));
      result7->obj.i = (long)p;
      result7->ref = (long)p;
      result7->type = 'u';
      result7->tagnum = G__get_linked_tagnum(&G__G__Geom1LN_TGeoCombiTrans);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_163_6_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   TGeoCombiTrans *p=NULL;
      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]));
      result7->obj.i = (long)p;
      result7->ref = (long)p;
      result7->type = 'u';
      result7->tagnum = G__get_linked_tagnum(&G__G__Geom1LN_TGeoCombiTrans);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_163_7_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   TGeoCombiTrans *p=NULL;
      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]));
      result7->obj.i = (long)p;
      result7->ref = (long)p;
      result7->type = 'u';
      result7->tagnum = G__get_linked_tagnum(&G__G__Geom1LN_TGeoCombiTrans);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_163_8_0(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_163_9_0(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_163_0_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   switch(libp->paran) {
   case 1:
      G__setnull(result7);
      ((TGeoCombiTrans*)(G__getstructoffset()))->Clear((Option_t*)G__int(libp->para[0]));
      break;
   case 0:
      G__setnull(result7);
      ((TGeoCombiTrans*)(G__getstructoffset()))->Clear();
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_163_1_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      {
        const TGeoMatrix& obj=((const TGeoCombiTrans*)(G__getstructoffset()))->Inverse();
         result7->ref=(long)(&obj); result7->obj.i=(long)(&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__Geom1_163_3_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoCombiTrans*)(G__getstructoffset()))->RotateX((Double_t)G__double(libp->para[0]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_163_4_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoCombiTrans*)(G__getstructoffset()))->RotateY((Double_t)G__double(libp->para[0]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_163_5_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoCombiTrans*)(G__getstructoffset()))->RotateZ((Double_t)G__double(libp->para[0]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_163_6_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoCombiTrans*)(G__getstructoffset()))->SavePrimitive(*(ofstream*)libp->para[0].ref,(Option_t*)G__int(libp->para[1]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_163_7_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoCombiTrans*)(G__getstructoffset()))->SetTranslation(*(TGeoTranslation*)libp->para[0].ref);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_163_8_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((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]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_163_9_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoCombiTrans*)(G__getstructoffset()))->SetTranslation((Double_t*)G__int(libp->para[0]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_163_0_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoCombiTrans*)(G__getstructoffset()))->SetRotation(*(TGeoRotation*)libp->para[0].ref);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_163_1_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoCombiTrans*)(G__getstructoffset()))->SetRotation((const TGeoRotation*)G__int(libp->para[0]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_163_2_2(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_163_3_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   G__letint(result7,68,(long)((const TGeoCombiTrans*)(G__getstructoffset()))->GetTranslation());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_163_4_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   G__letint(result7,68,(long)((const TGeoCombiTrans*)(G__getstructoffset()))->GetRotationMatrix());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_163_5_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   G__letint(result7,68,(long)((const TGeoCombiTrans*)(G__getstructoffset()))->GetScale());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_163_6_2(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_163_7_2(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_163_8_2(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_163_9_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      TGeoCombiTrans::Dictionary();
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__Geom1_163_1_3(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoCombiTrans*)(G__getstructoffset()))->ShowMembers(*(TMemberInspector*)libp->para[0].ref,(char*)G__int(libp->para[1]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_163_2_3(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoCombiTrans*)(G__getstructoffset()))->Streamer(*(TBuffer*)libp->para[0].ref);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_163_3_3(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoCombiTrans*)(G__getstructoffset()))->StreamerNVirtual(*(TBuffer*)libp->para[0].ref);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_163_4_3(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_163_5_3(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_163_6_3(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_163_7_3(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_163_8_3(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   if(0==G__getstructoffset()) return(1);
   if(G__getaryconstruct())
     if(G__PVOID==G__getgvp())
       delete[] (TGeoCombiTrans *)(G__getstructoffset());
     else
       for(int i=G__getaryconstruct()-1;i>=0;i--)
         delete (TGeoCombiTrans *)((G__getstructoffset())+sizeof(TGeoCombiTrans)*i);
   else  delete (TGeoCombiTrans *)(G__getstructoffset());
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGeoGenTrans */
static int G__G__Geom1_164_1_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   TGeoGenTrans *p=NULL;
   if(G__getaryconstruct()) p=new TGeoGenTrans[G__getaryconstruct()];
   else                    p=new TGeoGenTrans;
      result7->obj.i = (long)p;
      result7->ref = (long)p;
      result7->type = 'u';
      result7->tagnum = G__get_linked_tagnum(&G__G__Geom1LN_TGeoGenTrans);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_164_2_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   TGeoGenTrans *p=NULL;
      p = new TGeoGenTrans((const char*)G__int(libp->para[0]));
      result7->obj.i = (long)p;
      result7->ref = (long)p;
      result7->type = 'u';
      result7->tagnum = G__get_linked_tagnum(&G__G__Geom1LN_TGeoGenTrans);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_164_3_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   TGeoGenTrans *p=NULL;
      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]));
      result7->obj.i = (long)p;
      result7->ref = (long)p;
      result7->type = 'u';
      result7->tagnum = G__get_linked_tagnum(&G__G__Geom1LN_TGeoGenTrans);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_164_4_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   TGeoGenTrans *p=NULL;
      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]));
      result7->obj.i = (long)p;
      result7->ref = (long)p;
      result7->type = 'u';
      result7->tagnum = G__get_linked_tagnum(&G__G__Geom1LN_TGeoGenTrans);
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__Geom1_164_6_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      {
        const TGeoMatrix& obj=((const TGeoGenTrans*)(G__getstructoffset()))->Inverse();
         result7->ref=(long)(&obj); result7->obj.i=(long)(&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_164_7_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((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]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_164_8_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoGenTrans*)(G__getstructoffset()))->SetScale((Double_t*)G__int(libp->para[0]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_164_9_0(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_164_0_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   G__letint(result7,68,(long)((const TGeoGenTrans*)(G__getstructoffset()))->GetScale());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_164_1_1(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_164_2_1(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_164_3_1(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_164_4_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      TGeoGenTrans::Dictionary();
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__Geom1_164_6_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoGenTrans*)(G__getstructoffset()))->ShowMembers(*(TMemberInspector*)libp->para[0].ref,(char*)G__int(libp->para[1]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_164_7_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoGenTrans*)(G__getstructoffset()))->Streamer(*(TBuffer*)libp->para[0].ref);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_164_8_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoGenTrans*)(G__getstructoffset()))->StreamerNVirtual(*(TBuffer*)libp->para[0].ref);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_164_9_1(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_164_0_2(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_164_1_2(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_164_2_2(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_164_3_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash)
{
   TGeoGenTrans *p;
   void *xtmp = (void*)G__int(libp->para[0]);
   p=new TGeoGenTrans(*(TGeoGenTrans*)xtmp);
   result7->obj.i = (long)p;
   result7->ref = (long)p;
   result7->type = 'u';
   result7->tagnum = 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_164_4_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   if(0==G__getstructoffset()) return(1);
   if(G__getaryconstruct())
     if(G__PVOID==G__getgvp())
       delete[] (TGeoGenTrans *)(G__getstructoffset());
     else
       for(int i=G__getaryconstruct()-1;i>=0;i--)
         delete (TGeoGenTrans *)((G__getstructoffset())+sizeof(TGeoGenTrans)*i);
   else  delete (TGeoGenTrans *)(G__getstructoffset());
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__G__Geom1_164_5_2(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_165_1_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   TGeoIdentity *p=NULL;
   if(G__getaryconstruct()) p=new TGeoIdentity[G__getaryconstruct()];
   else                    p=new TGeoIdentity;
      result7->obj.i = (long)p;
      result7->ref = (long)p;
      result7->type = 'u';
      result7->tagnum = G__get_linked_tagnum(&G__G__Geom1LN_TGeoIdentity);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_165_2_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   TGeoIdentity *p=NULL;
      p = new TGeoIdentity((const char*)G__int(libp->para[0]));
      result7->obj.i = (long)p;
      result7->ref = (long)p;
      result7->type = 'u';
      result7->tagnum = G__get_linked_tagnum(&G__G__Geom1LN_TGeoIdentity);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_165_3_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      {
        const TGeoMatrix& obj=((const TGeoIdentity*)(G__getstructoffset()))->Inverse();
         result7->ref=(long)(&obj); result7->obj.i=(long)(&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_165_4_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((const TGeoIdentity*)(G__getstructoffset()))->LocalToMaster((const 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_165_5_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((const TGeoIdentity*)(G__getstructoffset()))->LocalToMasterVect((const 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_165_6_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((const TGeoIdentity*)(G__getstructoffset()))->MasterToLocal((const 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_165_7_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((const TGeoIdentity*)(G__getstructoffset()))->MasterToLocalVect((const 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_165_8_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((const TGeoIdentity*)(G__getstructoffset()))->LocalToMasterBomb((const 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_165_9_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((const TGeoIdentity*)(G__getstructoffset()))->MasterToLocalBomb((const 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_165_0_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   G__letint(result7,68,(long)((const TGeoIdentity*)(G__getstructoffset()))->GetTranslation());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_165_1_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   G__letint(result7,68,(long)((const TGeoIdentity*)(G__getstructoffset()))->GetRotationMatrix());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_165_2_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   G__letint(result7,68,(long)((const TGeoIdentity*)(G__getstructoffset()))->GetScale());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_165_3_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoIdentity*)(G__getstructoffset()))->SavePrimitive(*(ofstream*)libp->para[0].ref,(Option_t*)G__int(libp->para[1]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_165_4_1(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_165_5_1(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_165_6_1(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_165_7_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      TGeoIdentity::Dictionary();
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__Geom1_165_9_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoIdentity*)(G__getstructoffset()))->ShowMembers(*(TMemberInspector*)libp->para[0].ref,(char*)G__int(libp->para[1]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_165_0_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoIdentity*)(G__getstructoffset()))->Streamer(*(TBuffer*)libp->para[0].ref);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_165_1_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoIdentity*)(G__getstructoffset()))->StreamerNVirtual(*(TBuffer*)libp->para[0].ref);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_165_2_2(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_165_3_2(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_165_4_2(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_165_5_2(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_165_6_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash)
{
   TGeoIdentity *p;
   void *xtmp = (void*)G__int(libp->para[0]);
   p=new TGeoIdentity(*(TGeoIdentity*)xtmp);
   result7->obj.i = (long)p;
   result7->ref = (long)p;
   result7->type = 'u';
   result7->tagnum = 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_165_7_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   if(0==G__getstructoffset()) return(1);
   if(G__getaryconstruct())
     if(G__PVOID==G__getgvp())
       delete[] (TGeoIdentity *)(G__getstructoffset());
     else
       for(int i=G__getaryconstruct()-1;i>=0;i--)
         delete (TGeoIdentity *)((G__getstructoffset())+sizeof(TGeoIdentity)*i);
   else  delete (TGeoIdentity *)(G__getstructoffset());
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__G__Geom1_165_8_2(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_169_2_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   TGeoBBox *p=NULL;
   if(G__getaryconstruct()) p=new TGeoBBox[G__getaryconstruct()];
   else                    p=new TGeoBBox;
      result7->obj.i = (long)p;
      result7->ref = (long)p;
      result7->type = 'u';
      result7->tagnum = G__get_linked_tagnum(&G__G__Geom1LN_TGeoBBox);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_169_3_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   TGeoBBox *p=NULL;
   switch(libp->paran) {
   case 4:
      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]));
      break;
   case 3:
      p = new 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;
      result7->type = 'u';
      result7->tagnum = G__get_linked_tagnum(&G__G__Geom1LN_TGeoBBox);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_169_4_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   TGeoBBox *p=NULL;
   switch(libp->paran) {
   case 5:
      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]));
      break;
   case 4:
      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]));
      break;
   }
      result7->obj.i = (long)p;
      result7->ref = (long)p;
      result7->type = 'u';
      result7->tagnum = G__get_linked_tagnum(&G__G__Geom1LN_TGeoBBox);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_169_5_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   TGeoBBox *p=NULL;
      p = new TGeoBBox((Double_t*)G__int(libp->para[0]));
      result7->obj.i = (long)p;
      result7->ref = (long)p;
      result7->type = 'u';
      result7->tagnum = G__get_linked_tagnum(&G__G__Geom1LN_TGeoBBox);
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__Geom1_169_7_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoBBox*)(G__getstructoffset()))->ComputeNormal((Double_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_169_8_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__letint(result7,103,(long)((const TGeoBBox*)(G__getstructoffset()))->Contains((Double_t*)G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_169_9_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__letint(result7,103,(long)((const TGeoBBox*)(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_169_0_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__letint(result7,105,(long)((TGeoBBox*)(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_169_1_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   switch(libp->paran) {
   case 5:
      G__letdouble(result7,100,(double)((const TGeoBBox*)(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 TGeoBBox*)(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 TGeoBBox*)(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 TGeoBBox*)(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_169_2_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   switch(libp->paran) {
   case 5:
      G__letdouble(result7,100,(double)((const TGeoBBox*)(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 TGeoBBox*)(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 TGeoBBox*)(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 TGeoBBox*)(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_169_3_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   G__letint(result7,85,(long)((TGeoBBox*)(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_169_4_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   G__letint(result7,67,(long)((const TGeoBBox*)(G__getstructoffset()))->GetAxisName((Int_t)G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_169_5_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__letdouble(result7,100,(double)((const TGeoBBox*)(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_169_6_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((const TGeoBBox*)(G__getstructoffset()))->GetBoundingCylinder((Double_t*)G__int(libp->para[0]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_169_7_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      {
        const TBuffer3D& obj=((const TGeoBBox*)(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_169_8_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__letint(result7,105,(long)((const TGeoBBox*)(G__getstructoffset()))->GetByteCount());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_169_9_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__letint(result7,105,(long)((const TGeoBBox*)(G__getstructoffset()))->GetFittingBox((const 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_169_0_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   G__letint(result7,85,(long)((const TGeoBBox*)(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_169_1_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__letint(result7,105,(long)((const TGeoBBox*)(G__getstructoffset()))->GetNmeshVertices());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_169_2_2(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_169_3_2(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_169_4_2(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_169_5_2(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_169_6_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((const TGeoBBox*)(G__getstructoffset()))->InspectShape();
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_169_7_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__letint(result7,103,(long)((const TGeoBBox*)(G__getstructoffset()))->IsCylType());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_169_8_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__letint(result7,103,(long)((const TGeoBBox*)(G__getstructoffset()))->IsValidBox());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_169_9_2(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_169_0_3(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   G__letint(result7,85,(long)((const TGeoBBox*)(G__getstructoffset()))->MakeBuffer3D());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_169_1_3(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   switch(libp->paran) {
   case 2:
      G__letdouble(result7,100,(double)((const TGeoBBox*)(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 TGeoBBox*)(G__getstructoffset()))->Safety((Double_t*)G__int(libp->para[0])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_169_2_3(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoBBox*)(G__getstructoffset()))->SavePrimitive(*(ofstream*)libp->para[0].ref,(Option_t*)G__int(libp->para[1]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_169_3_3(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   switch(libp->paran) {
   case 4:
      G__setnull(result7);
      ((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]));
      break;
   case 3:
      G__setnull(result7);
      ((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]));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_169_4_3(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoBBox*)(G__getstructoffset()))->SetDimensions((Double_t*)G__int(libp->para[0]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_169_5_3(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((const TGeoBBox*)(G__getstructoffset()))->SetBoxPoints((Double_t*)G__int(libp->para[0]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_169_6_3(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((const TGeoBBox*)(G__getstructoffset()))->SetPoints((Double_t*)G__int(libp->para[0]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_169_7_3(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((const TGeoBBox*)(G__getstructoffset()))->SetPoints((Float_t*)G__int(libp->para[0]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_169_8_3(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((const TGeoBBox*)(G__getstructoffset()))->SetSegsAndPols(*(TBuffer3D*)libp->para[0].ref);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_169_9_3(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((const TGeoBBox*)(G__getstructoffset()))->Sizeof3D();
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_169_0_4(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_169_1_4(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_169_2_4(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_169_3_4(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      TGeoBBox::Dictionary();
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__Geom1_169_5_4(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoBBox*)(G__getstructoffset()))->ShowMembers(*(TMemberInspector*)libp->para[0].ref,(char*)G__int(libp->para[1]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_169_6_4(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoBBox*)(G__getstructoffset()))->Streamer(*(TBuffer*)libp->para[0].ref);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_169_7_4(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoBBox*)(G__getstructoffset()))->StreamerNVirtual(*(TBuffer*)libp->para[0].ref);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_169_8_4(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_169_9_4(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_169_0_5(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_169_1_5(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_169_2_5(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash)
{
   TGeoBBox *p;
   void *xtmp = (void*)G__int(libp->para[0]);
   p=new TGeoBBox(*(TGeoBBox*)xtmp);
   result7->obj.i = (long)p;
   result7->ref = (long)p;
   result7->type = 'u';
   result7->tagnum = 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_169_3_5(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   if(0==G__getstructoffset()) return(1);
   if(G__getaryconstruct())
     if(G__PVOID==G__getgvp())
       delete[] (TGeoBBox *)(G__getstructoffset());
     else
       for(int i=G__getaryconstruct()-1;i>=0;i--)
         delete (TGeoBBox *)((G__getstructoffset())+sizeof(TGeoBBox)*i);
   else  delete (TGeoBBox *)(G__getstructoffset());
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__G__Geom1_169_4_5(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_170_1_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   TGeoVolume *p=NULL;
   if(G__getaryconstruct()) p=new TGeoVolume[G__getaryconstruct()];
   else                    p=new TGeoVolume;
      result7->obj.i = (long)p;
      result7->ref = (long)p;
      result7->type = 'u';
      result7->tagnum = G__get_linked_tagnum(&G__G__Geom1LN_TGeoVolume);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_170_2_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   TGeoVolume *p=NULL;
   switch(libp->paran) {
   case 3:
      p = new TGeoVolume(
(const char*)G__int(libp->para[0]),(const TGeoShape*)G__int(libp->para[1])
,(const TGeoMedium*)G__int(libp->para[2]));
      break;
   case 2:
      p = new TGeoVolume((const char*)G__int(libp->para[0]),(const TGeoShape*)G__int(libp->para[1]));
      break;
   }
      result7->obj.i = (long)p;
      result7->ref = (long)p;
      result7->type = 'u';
      result7->tagnum = G__get_linked_tagnum(&G__G__Geom1LN_TGeoVolume);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_170_3_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((const TGeoVolume*)(G__getstructoffset()))->cd((Int_t)G__int(libp->para[0]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_170_4_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoVolume*)(G__getstructoffset()))->Browse((TBrowser*)G__int(libp->para[0]));
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

static int G__G__Geom1_170_9_0(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_170_0_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   switch(libp->paran) {
   case 4:
      G__setnull(result7);
      ((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]));
      break;
   case 3:
      G__setnull(result7);
      ((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]));
      break;
   case 2:
      G__setnull(result7);
      ((const TGeoVolume*)(G__getstructoffset()))->CheckGeometry((Int_t)G__int(libp->para[0]),(Double_t)G__double(libp->para[1]));
      break;
   case 1:
      G__setnull(result7);
      ((const TGeoVolume*)(G__getstructoffset()))->CheckGeometry((Int_t)G__int(libp->para[0]));
      break;
   case 0:
      G__setnull(result7);
      ((const TGeoVolume*)(G__getstructoffset()))->CheckGeometry();
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_170_1_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   switch(libp->paran) {
   case 2:
      G__setnull(result7);
      ((const TGeoVolume*)(G__getstructoffset()))->CheckOverlaps((Double_t)G__double(libp->para[0]),(Option_t*)G__int(libp->para[1]));
      break;
   case 1:
      G__setnull(result7);
      ((const TGeoVolume*)(G__getstructoffset()))->CheckOverlaps((Double_t)G__double(libp->para[0]));
      break;
   case 0:
      G__setnull(result7);
      ((const TGeoVolume*)(G__getstructoffset()))->CheckOverlaps();
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_170_2_1(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_170_3_1(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_170_4_1(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_170_5_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__letint(result7,103,(long)((const TGeoVolume*)(G__getstructoffset()))->IsFolder());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_170_6_1(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_170_7_1(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_170_8_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   switch(libp->paran) {
   case 4:
      G__setnull(result7);
      ((TGeoVolume*)(G__getstructoffset()))->AddNode((const 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]));
      break;
   case 3:
      G__setnull(result7);
      ((TGeoVolume*)(G__getstructoffset()))->AddNode((const TGeoVolume*)G__int(libp->para[0]),(Int_t)G__int(libp->para[1])
,(TGeoMatrix*)G__int(libp->para[2]));
      break;
   case 2:
      G__setnull(result7);
      ((TGeoVolume*)(G__getstructoffset()))->AddNode((const TGeoVolume*)G__int(libp->para[0]),(Int_t)G__int(libp->para[1]));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_170_9_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   switch(libp->paran) {
   case 4:
      G__setnull(result7);
      ((TGeoVolume*)(G__getstructoffset()))->AddNodeOffset((const 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]));
      break;
   case 3:
      G__setnull(result7);
      ((TGeoVolume*)(G__getstructoffset()))->AddNodeOffset((const TGeoVolume*)G__int(libp->para[0]),(Int_t)G__int(libp->para[1])
,(Double_t)G__double(libp->para[2]));
      break;
   case 2:
      G__setnull(result7);
      ((TGeoVolume*)(G__getstructoffset()))->AddNodeOffset((const TGeoVolume*)G__int(libp->para[0]),(Int_t)G__int(libp->para[1]));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_170_0_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   switch(libp->paran) {
   case 4:
      G__setnull(result7);
      ((TGeoVolume*)(G__getstructoffset()))->AddNodeOverlap((const 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]));
      break;
   case 3:
      G__setnull(result7);
      ((TGeoVolume*)(G__getstructoffset()))->AddNodeOverlap((const TGeoVolume*)G__int(libp->para[0]),(Int_t)G__int(libp->para[1])
,(TGeoMatrix*)G__int(libp->para[2]));
      break;
   case 2:
      G__setnull(result7);
      ((TGeoVolume*)(G__getstructoffset()))->AddNodeOverlap((const TGeoVolume*)G__int(libp->para[0]),(Int_t)G__int(libp->para[1]));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_170_1_2(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_170_2_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__letint(result7,105,(long)((TGeoVolume*)(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_170_3_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   switch(libp->paran) {
   case 1:
      G__setnull(result7);
      ((TGeoVolume*)(G__getstructoffset()))->Draw((Option_t*)G__int(libp->para[0]));
      break;
   case 0:
      G__setnull(result7);
      ((TGeoVolume*)(G__getstructoffset()))->Draw();
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__Geom1_170_5_2(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_170_6_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   switch(libp->paran) {
   case 1:
      G__setnull(result7);
      ((TGeoVolume*)(G__getstructoffset()))->Paint((Option_t*)G__int(libp->para[0]));
      break;
   case 0:
      G__setnull(result7);
      ((TGeoVolume*)(G__getstructoffset()))->Paint();
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_170_7_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((const TGeoVolume*)(G__getstructoffset()))->PrintNodes();
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_170_8_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((const TGeoVolume*)(G__getstructoffset()))->PrintVoxels();
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_170_9_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoVolume*)(G__getstructoffset()))->ExecuteEvent((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_170_0_3(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_170_1_3(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_170_2_3(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_170_3_3(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_170_4_3(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__letint(result7,103,(long)((const TGeoVolume*)(G__getstructoffset()))->IsVisible());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_170_5_3(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_170_6_3(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_170_7_3(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_170_8_3(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_170_9_3(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((const TGeoVolume*)(G__getstructoffset()))->FindOverlaps();
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_170_0_4(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_170_1_4(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_170_2_4(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_170_3_4(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_170_4_4(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_170_5_4(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_170_6_4(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_170_7_4(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_170_8_4(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_170_9_4(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_170_0_5(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_170_1_5(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__letint(result7,105,(long)((const TGeoVolume*)(G__getstructoffset()))->GetIndex((const TGeoNode*)G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_170_2_5(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_170_3_5(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_170_4_5(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__letint(result7,105,(long)((const TGeoVolume*)(G__getstructoffset()))->GetNodeIndex((const 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_170_5_5(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_170_6_5(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   G__letint(result7,67,(long)((const TGeoVolume*)(G__getstructoffset()))->GetObjectInfo((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_170_7_5(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_170_8_5(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   G__letint(result7,67,(long)((const TGeoVolume*)(G__getstructoffset()))->GetOption());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_170_9_5(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_170_0_6(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_170_1_6(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_170_2_6(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoVolume*)(G__getstructoffset()))->GrabFocus();
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_170_3_6(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoVolume*)(G__getstructoffset()))->Gsord((Int_t)G__int(libp->para[0]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_170_4_6(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_170_5_6(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((const TGeoVolume*)(G__getstructoffset()))->InspectMaterial();
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_170_6_6(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((const TGeoVolume*)(G__getstructoffset()))->InspectShape();
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_170_7_6(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_170_8_6(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoVolume*)(G__getstructoffset()))->MakeCopyNodes((const TGeoVolume*)G__int(libp->para[0]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_170_9_6(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_170_0_7(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   switch(libp->paran) {
   case 2:
      G__setnull(result7);
      ((TGeoVolume*)(G__getstructoffset()))->RandomPoints((Int_t)G__int(libp->para[0]),(Option_t*)G__int(libp->para[1]));
      break;
   case 1:
      G__setnull(result7);
      ((TGeoVolume*)(G__getstructoffset()))->RandomPoints((Int_t)G__int(libp->para[0]));
      break;
   case 0:
      G__setnull(result7);
      ((TGeoVolume*)(G__getstructoffset()))->RandomPoints();
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_170_1_7(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   switch(libp->paran) {
   case 4:
      G__setnull(result7);
      ((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]));
      break;
   case 3:
      G__setnull(result7);
      ((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]));
      break;
   case 2:
      G__setnull(result7);
      ((TGeoVolume*)(G__getstructoffset()))->RandomRays((Int_t)G__int(libp->para[0]),(Double_t)G__double(libp->para[1]));
      break;
   case 1:
      G__setnull(result7);
      ((TGeoVolume*)(G__getstructoffset()))->RandomRays((Int_t)G__int(libp->para[0]));
      break;
   case 0:
      G__setnull(result7);
      ((TGeoVolume*)(G__getstructoffset()))->RandomRays();
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__Geom1_170_3_7(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoVolume*)(G__getstructoffset()))->SaveAs((const char*)G__int(libp->para[0]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_170_4_7(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoVolume*)(G__getstructoffset()))->SavePrimitive(*(ofstream*)libp->para[0].ref,(Option_t*)G__int(libp->para[1]));
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__Geom1_170_6_7(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((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]));
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__Geom1_170_8_7(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoVolume*)(G__getstructoffset()))->SetNodes((TObjArray*)G__int(libp->para[0]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_170_9_7(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoVolume*)(G__getstructoffset()))->SetShape((const TGeoShape*)G__int(libp->para[0]));
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__Geom1_170_1_8(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoVolume*)(G__getstructoffset()))->SetField((const TObject*)G__int(libp->para[0]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_170_2_8(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoVolume*)(G__getstructoffset()))->SetOption((const char*)G__int(libp->para[0]));
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__Geom1_170_4_8(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoVolume*)(G__getstructoffset()))->SetLineColor((Color_t)G__int(libp->para[0]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_170_5_8(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoVolume*)(G__getstructoffset()))->SetLineStyle((Style_t)G__int(libp->para[0]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_170_6_8(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoVolume*)(G__getstructoffset()))->SetLineWidth((Width_t)G__int(libp->para[0]));
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__Geom1_170_8_8(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoVolume*)(G__getstructoffset()))->SetMedium((const TGeoMedium*)G__int(libp->para[0]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_170_9_8(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoVolume*)(G__getstructoffset()))->SetVoxelFinder((const TGeoVoxelFinder*)G__int(libp->para[0]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_170_0_9(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoVolume*)(G__getstructoffset()))->SetFinder((const TGeoPatternFinder*)G__int(libp->para[0]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_170_1_9(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoVolume*)(G__getstructoffset()))->SetNumber((Int_t)G__int(libp->para[0]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_170_2_9(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoVolume*)(G__getstructoffset()))->SetNtotal((Int_t)G__int(libp->para[0]));
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

static int G__G__Geom1_170_5_9(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_170_6_9(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   switch(libp->paran) {
   case 1:
      G__setnull(result7);
      ((TGeoVolume*)(G__getstructoffset()))->VisibleDaughters((Bool_t)G__int(libp->para[0]));
      break;
   case 0:
      G__setnull(result7);
      ((TGeoVolume*)(G__getstructoffset()))->VisibleDaughters();
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__Geom1_170_8_9(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoVolume*)(G__getstructoffset()))->Voxelize((Option_t*)G__int(libp->para[0]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_170_9_9(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_170_0_10(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_170_1_10(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_170_2_10(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_170_3_10(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      TGeoVolume::Dictionary();
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__Geom1_170_5_10(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoVolume*)(G__getstructoffset()))->ShowMembers(*(TMemberInspector*)libp->para[0].ref,(char*)G__int(libp->para[1]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_170_6_10(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoVolume*)(G__getstructoffset()))->Streamer(*(TBuffer*)libp->para[0].ref);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_170_7_10(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoVolume*)(G__getstructoffset()))->StreamerNVirtual(*(TBuffer*)libp->para[0].ref);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_170_8_10(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_170_9_10(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_170_0_11(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_170_1_11(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 copy constructor
static int G__G__Geom1_170_2_11(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash)
{
   TGeoVolume *p;
   void *xtmp = (void*)G__int(libp->para[0]);
   p=new TGeoVolume(*(TGeoVolume*)xtmp);
   result7->obj.i = (long)p;
   result7->ref = (long)p;
   result7->type = 'u';
   result7->tagnum = G__get_linked_tagnum(&G__G__Geom1LN_TGeoVolume);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGeoVolume G__TTGeoVolume;
static int G__G__Geom1_170_3_11(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   if(0==G__getstructoffset()) return(1);
   if(G__getaryconstruct())
     if(G__PVOID==G__getgvp())
       delete[] (TGeoVolume *)(G__getstructoffset());
     else
       for(int i=G__getaryconstruct()-1;i>=0;i--)
         delete (TGeoVolume *)((G__getstructoffset())+sizeof(TGeoVolume)*i);
   else  delete (TGeoVolume *)(G__getstructoffset());
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__G__Geom1_170_4_11(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   TGeoVolume *dest = (TGeoVolume*)(G__getstructoffset());
   *dest = (*(TGeoVolume*)libp->para[0].ref);
   const TGeoVolume& obj = *dest;
   result7->ref=(long)(&obj); result7->obj.i=(long)(&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGeoNode */
static int G__G__Geom1_174_3_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoNode*)(G__getstructoffset()))->Browse((TBrowser*)G__int(libp->para[0]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_174_4_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((const TGeoNode*)(G__getstructoffset()))->cd();
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

static int G__G__Geom1_174_9_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((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]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_174_0_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__letint(result7,105,(long)((TGeoNode*)(G__getstructoffset()))->FindNode((const TGeoNode*)G__int(libp->para[0]),(Int_t)G__int(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_174_1_1(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_174_2_1(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_174_3_1(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_174_4_1(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_174_5_1(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_174_6_1(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_174_7_1(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_174_8_1(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_174_9_1(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_174_0_2(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_174_1_2(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_174_2_2(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_174_3_2(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_174_4_2(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_174_5_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((const TGeoNode*)(G__getstructoffset()))->InspectNode();
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_174_6_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__letint(result7,103,(long)((const TGeoNode*)(G__getstructoffset()))->IsFolder());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_174_7_2(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_174_8_2(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_174_9_2(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_174_0_3(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_174_1_3(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_174_2_3(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_174_3_3(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_174_4_3(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_174_5_3(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoNode*)(G__getstructoffset()))->SaveAttributes(*(ofstream*)libp->para[0].ref);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_174_6_3(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((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]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_174_7_3(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoNode*)(G__getstructoffset()))->SetVolume((const TGeoVolume*)G__int(libp->para[0]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_174_8_3(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoNode*)(G__getstructoffset()))->SetNumber((Int_t)G__int(libp->para[0]));
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

static int G__G__Geom1_174_4_4(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoNode*)(G__getstructoffset()))->SetMotherVolume((const TGeoVolume*)G__int(libp->para[0]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_174_5_4(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoNode*)(G__getstructoffset()))->SetOverlaps((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_174_6_4(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((const TGeoNode*)(G__getstructoffset()))->MasterToLocal((const 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_174_7_4(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((const TGeoNode*)(G__getstructoffset()))->MasterToLocalVect((const 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_174_8_4(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((const TGeoNode*)(G__getstructoffset()))->LocalToMaster((const 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_174_9_4(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((const TGeoNode*)(G__getstructoffset()))->LocalToMasterVect((const 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_174_0_5(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   switch(libp->paran) {
   case 1:
      G__setnull(result7);
      ((const TGeoNode*)(G__getstructoffset()))->ls((Option_t*)G__int(libp->para[0]));
      break;
   case 0:
      G__setnull(result7);
      ((const TGeoNode*)(G__getstructoffset()))->ls();
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__Geom1_174_2_5(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((const TGeoNode*)(G__getstructoffset()))->PrintCandidates();
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_174_3_5(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((const TGeoNode*)(G__getstructoffset()))->PrintOverlaps();
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__Geom1_174_5_5(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_174_6_5(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_174_7_5(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_174_8_5(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      TGeoNode::Dictionary();
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__Geom1_174_0_6(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoNode*)(G__getstructoffset()))->ShowMembers(*(TMemberInspector*)libp->para[0].ref,(char*)G__int(libp->para[1]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_174_1_6(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoNode*)(G__getstructoffset()))->Streamer(*(TBuffer*)libp->para[0].ref);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_174_2_6(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoNode*)(G__getstructoffset()))->StreamerNVirtual(*(TBuffer*)libp->para[0].ref);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_174_3_6(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_174_4_6(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_174_5_6(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_174_6_6(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_174_7_6(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   if(0==G__getstructoffset()) return(1);
   if(G__getaryconstruct())
     if(G__PVOID==G__getgvp())
       delete[] (TGeoNode *)(G__getstructoffset());
     else
       for(int i=G__getaryconstruct()-1;i>=0;i--)
         delete (TGeoNode *)((G__getstructoffset())+sizeof(TGeoNode)*i);
   else  delete (TGeoNode *)(G__getstructoffset());
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__G__Geom1_174_8_6(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   TGeoNode *dest = (TGeoNode*)(G__getstructoffset());
   *dest = (*(TGeoNode*)libp->para[0].ref);
   const TGeoNode& obj = *dest;
   result7->ref=(long)(&obj); result7->obj.i=(long)(&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGeoVoxelFinder */
static int G__G__Geom1_175_1_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   TGeoVoxelFinder *p=NULL;
   if(G__getaryconstruct()) p=new TGeoVoxelFinder[G__getaryconstruct()];
   else                    p=new TGeoVoxelFinder;
      result7->obj.i = (long)p;
      result7->ref = (long)p;
      result7->type = 'u';
      result7->tagnum = G__get_linked_tagnum(&G__G__Geom1LN_TGeoVoxelFinder);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_175_2_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   TGeoVoxelFinder *p=NULL;
      p = new TGeoVoxelFinder((TGeoVolume*)G__int(libp->para[0]));
      result7->obj.i = (long)p;
      result7->ref = (long)p;
      result7->type = 'u';
      result7->tagnum = G__get_linked_tagnum(&G__G__Geom1LN_TGeoVoxelFinder);
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

static int G__G__Geom1_175_5_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((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]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_175_6_0(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_175_7_0(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_175_8_0(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_175_9_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   G__letint(result7,73,(long)((const TGeoVoxelFinder*)(G__getstructoffset()))->GetExtraX((Int_t)G__int(libp->para[0]),(Bool_t)G__int(libp->para[1])
,*(Int_t*)G__Intref(&libp->para[2])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_175_0_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   G__letint(result7,73,(long)((const TGeoVoxelFinder*)(G__getstructoffset()))->GetExtraY((Int_t)G__int(libp->para[0]),(Bool_t)G__int(libp->para[1])
,*(Int_t*)G__Intref(&libp->para[2])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_175_1_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   G__letint(result7,73,(long)((const TGeoVoxelFinder*)(G__getstructoffset()))->GetExtraZ((Int_t)G__int(libp->para[0]),(Bool_t)G__int(libp->para[1])
,*(Int_t*)G__Intref(&libp->para[2])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_175_2_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__letint(result7,103,(long)((TGeoVoxelFinder*)(G__getstructoffset()))->GetIndices((Double_t*)G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_175_3_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__letint(result7,105,(long)((const TGeoVoxelFinder*)(G__getstructoffset()))->GetPriority((Int_t)G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_175_4_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__letint(result7,105,(long)((const TGeoVoxelFinder*)(G__getstructoffset()))->GetNcandidates());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_175_5_1(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_175_6_1(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_175_7_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   G__letint(result7,73,(long)((TGeoVoxelFinder*)(G__getstructoffset()))->GetValidExtra((Int_t*)G__int(libp->para[0]),*(Int_t*)G__Intref(&libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_175_8_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   G__letint(result7,73,(long)((TGeoVoxelFinder*)(G__getstructoffset()))->GetValidExtra((Int_t)G__int(libp->para[0]),(UChar_t*)G__int(libp->para[1])
,(Int_t*)G__int(libp->para[2]),*(Int_t*)G__Intref(&libp->para[3])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_175_9_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   G__letint(result7,73,(long)((TGeoVoxelFinder*)(G__getstructoffset()))->GetValidExtra((Int_t)G__int(libp->para[0]),(UChar_t*)G__int(libp->para[1])
,(Int_t)G__int(libp->para[2]),(UChar_t*)G__int(libp->para[3])
,(Int_t*)G__int(libp->para[4]),*(Int_t*)G__Intref(&libp->para[5])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_175_0_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   G__letint(result7,73,(long)((TGeoVoxelFinder*)(G__getstructoffset()))->GetVoxelCandidates((Int_t)G__int(libp->para[0]),(Int_t)G__int(libp->para[1])
,(Int_t)G__int(libp->para[2]),*(Int_t*)G__Intref(&libp->para[3])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_175_1_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((const TGeoVoxelFinder*)(G__getstructoffset()))->FindOverlaps((Int_t)G__int(libp->para[0]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_175_2_2(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_175_3_2(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_175_4_2(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_175_5_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   switch(libp->paran) {
   case 1:
      G__setnull(result7);
      ((const TGeoVoxelFinder*)(G__getstructoffset()))->Print((Option_t*)G__int(libp->para[0]));
      break;
   case 0:
      G__setnull(result7);
      ((const TGeoVoxelFinder*)(G__getstructoffset()))->Print();
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_175_6_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((const TGeoVoxelFinder*)(G__getstructoffset()))->PrintVoxelLimits((Double_t*)G__int(libp->para[0]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_175_7_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__letint(result7,103,(long)((TGeoVoxelFinder*)(G__getstructoffset()))->Intersect((Int_t)G__int(libp->para[0]),(UChar_t*)G__int(libp->para[1])
,*(Int_t*)G__Intref(&libp->para[2]),(Int_t*)G__int(libp->para[3])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_175_8_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__letint(result7,103,(long)((TGeoVoxelFinder*)(G__getstructoffset()))->Intersect((Int_t)G__int(libp->para[0]),(UChar_t*)G__int(libp->para[1])
,(Int_t)G__int(libp->para[2]),(UChar_t*)G__int(libp->para[3])
,*(Int_t*)G__Intref(&libp->para[4]),(Int_t*)G__int(libp->para[5])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_175_9_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__letint(result7,103,(long)((TGeoVoxelFinder*)(G__getstructoffset()))->Intersect(
(Int_t)G__int(libp->para[0]),(UChar_t*)G__int(libp->para[1])
,(Int_t)G__int(libp->para[2]),(UChar_t*)G__int(libp->para[3])
,(Int_t)G__int(libp->para[4]),(UChar_t*)G__int(libp->para[5])
,*(Int_t*)G__Intref(&libp->para[6]),(Int_t*)G__int(libp->para[7])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_175_0_3(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__letint(result7,103,(long)((TGeoVoxelFinder*)(G__getstructoffset()))->IntersectAndStore((Int_t)G__int(libp->para[0]),(UChar_t*)G__int(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_175_1_3(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__letint(result7,103,(long)((TGeoVoxelFinder*)(G__getstructoffset()))->IntersectAndStore((Int_t)G__int(libp->para[0]),(UChar_t*)G__int(libp->para[1])
,(Int_t)G__int(libp->para[2]),(UChar_t*)G__int(libp->para[3])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_175_2_3(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__letint(result7,103,(long)((TGeoVoxelFinder*)(G__getstructoffset()))->IntersectAndStore((Int_t)G__int(libp->para[0]),(UChar_t*)G__int(libp->para[1])
,(Int_t)G__int(libp->para[2]),(UChar_t*)G__int(libp->para[3])
,(Int_t)G__int(libp->para[4]),(UChar_t*)G__int(libp->para[5])));
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

static int G__G__Geom1_175_5_3(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoVoxelFinder*)(G__getstructoffset()))->SortCrossedVoxels((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_175_6_3(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__letint(result7,103,(long)((TGeoVoxelFinder*)(G__getstructoffset()))->Union((Int_t)G__int(libp->para[0]),(UChar_t*)G__int(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_175_7_3(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__letint(result7,103,(long)((TGeoVoxelFinder*)(G__getstructoffset()))->Union((Int_t)G__int(libp->para[0]),(UChar_t*)G__int(libp->para[1])
,(Int_t)G__int(libp->para[2]),(UChar_t*)G__int(libp->para[3])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_175_8_3(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__letint(result7,103,(long)((TGeoVoxelFinder*)(G__getstructoffset()))->Union((Int_t)G__int(libp->para[0]),(UChar_t*)G__int(libp->para[1])
,(Int_t)G__int(libp->para[2]),(UChar_t*)G__int(libp->para[3])
,(Int_t)G__int(libp->para[4]),(UChar_t*)G__int(libp->para[5])));
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__Geom1_175_0_4(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_175_1_4(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_175_2_4(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_175_3_4(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      TGeoVoxelFinder::Dictionary();
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__Geom1_175_5_4(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoVoxelFinder*)(G__getstructoffset()))->ShowMembers(*(TMemberInspector*)libp->para[0].ref,(char*)G__int(libp->para[1]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_175_6_4(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoVoxelFinder*)(G__getstructoffset()))->Streamer(*(TBuffer*)libp->para[0].ref);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_175_7_4(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoVoxelFinder*)(G__getstructoffset()))->StreamerNVirtual(*(TBuffer*)libp->para[0].ref);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_175_8_4(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_175_9_4(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_175_0_5(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_175_1_5(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 copy constructor
static int G__G__Geom1_175_2_5(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash)
{
   TGeoVoxelFinder *p;
   void *xtmp = (void*)G__int(libp->para[0]);
   p=new TGeoVoxelFinder(*(TGeoVoxelFinder*)xtmp);
   result7->obj.i = (long)p;
   result7->ref = (long)p;
   result7->type = 'u';
   result7->tagnum = G__get_linked_tagnum(&G__G__Geom1LN_TGeoVoxelFinder);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGeoVoxelFinder G__TTGeoVoxelFinder;
static int G__G__Geom1_175_3_5(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   if(0==G__getstructoffset()) return(1);
   if(G__getaryconstruct())
     if(G__PVOID==G__getgvp())
       delete[] (TGeoVoxelFinder *)(G__getstructoffset());
     else
       for(int i=G__getaryconstruct()-1;i>=0;i--)
         delete (TGeoVoxelFinder *)((G__getstructoffset())+sizeof(TGeoVoxelFinder)*i);
   else  delete (TGeoVoxelFinder *)(G__getstructoffset());
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__G__Geom1_175_4_5(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   TGeoVoxelFinder *dest = (TGeoVoxelFinder*)(G__getstructoffset());
   *dest = (*(TGeoVoxelFinder*)libp->para[0].ref);
   const TGeoVoxelFinder& obj = *dest;
   result7->ref=(long)(&obj); result7->obj.i=(long)(&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGeoManager */
static int G__G__Geom1_177_0_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   TGeoManager *p=NULL;
   if(G__getaryconstruct()) p=new TGeoManager[G__getaryconstruct()];
   else                    p=new TGeoManager;
      result7->obj.i = (long)p;
      result7->ref = (long)p;
      result7->type = 'u';
      result7->tagnum = G__get_linked_tagnum(&G__G__Geom1LN_TGeoManager);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_177_1_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   TGeoManager *p=NULL;
      p = new TGeoManager((const char*)G__int(libp->para[0]),(const char*)G__int(libp->para[1]));
      result7->obj.i = (long)p;
      result7->ref = (long)p;
      result7->type = 'u';
      result7->tagnum = G__get_linked_tagnum(&G__G__Geom1LN_TGeoManager);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_177_2_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__letint(result7,105,(long)((TGeoManager*)(G__getstructoffset()))->AddMaterial((const TGeoMaterial*)G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_177_3_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__letint(result7,105,(long)((TGeoManager*)(G__getstructoffset()))->AddOverlap((const TNamed*)G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_177_4_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__letint(result7,105,(long)((TGeoManager*)(G__getstructoffset()))->AddTransformation((const TGeoMatrix*)G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_177_5_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__letint(result7,105,(long)((TGeoManager*)(G__getstructoffset()))->AddShape((const TGeoShape*)G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_177_6_1(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_177_7_1(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_177_8_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoManager*)(G__getstructoffset()))->ClearOverlaps();
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_177_9_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoManager*)(G__getstructoffset()))->RegisterMatrix((const TGeoMatrix*)G__int(libp->para[0]));
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__Geom1_177_1_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoManager*)(G__getstructoffset()))->Browse((TBrowser*)G__int(libp->para[0]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_177_2_2(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_177_3_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoManager*)(G__getstructoffset()))->CdNode((Int_t)G__int(libp->para[0]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_177_4_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoManager*)(G__getstructoffset()))->CdDown((Int_t)G__int(libp->para[0]));
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

static int G__G__Geom1_177_7_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((const TGeoManager*)(G__getstructoffset()))->GetBranchNames((Int_t*)G__int(libp->para[0]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_177_8_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((const TGeoManager*)(G__getstructoffset()))->GetBranchNumbers((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_177_9_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((const TGeoManager*)(G__getstructoffset()))->GetBranchOnlys((Int_t*)G__int(libp->para[0]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_177_0_3(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_177_1_3(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoManager*)(G__getstructoffset()))->SetPdgName((Int_t)G__int(libp->para[0]),(const char*)G__int(libp->para[1]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_177_2_3(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__letint(result7,103,(long)((const TGeoManager*)(G__getstructoffset()))->IsFolder());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_177_3_3(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoManager*)(G__getstructoffset()))->BombTranslation((const 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_177_4_3(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoManager*)(G__getstructoffset()))->UnbombTranslation((const 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_177_5_3(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoManager*)(G__getstructoffset()))->ClearAttributes();
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

static int G__G__Geom1_177_8_3(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_177_9_3(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_177_0_4(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_177_1_4(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_177_2_4(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_177_3_4(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((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]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_177_4_4(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_177_5_4(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_177_6_4(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_177_7_4(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_177_8_4(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_177_9_4(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_177_0_5(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_177_1_5(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_177_2_5(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_177_3_5(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_177_4_5(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((const TGeoManager*)(G__getstructoffset()))->ModifiedPad();
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

static int G__G__Geom1_177_7_5(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoManager*)(G__getstructoffset()))->SetClippingShape((TGeoShape*)G__int(libp->para[0]));
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__Geom1_177_9_5(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   switch(libp->paran) {
   case 2:
      G__setnull(result7);
      ((TGeoManager*)(G__getstructoffset()))->SetPhiRange((Double_t)G__double(libp->para[0]),(Double_t)G__double(libp->para[1]));
      break;
   case 1:
      G__setnull(result7);
      ((TGeoManager*)(G__getstructoffset()))->SetPhiRange((Double_t)G__double(libp->para[0]));
      break;
   case 0:
      G__setnull(result7);
      ((TGeoManager*)(G__getstructoffset()))->SetPhiRange();
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_177_0_6(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoManager*)(G__getstructoffset()))->SetNsegments((Int_t)G__int(libp->para[0]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_177_1_6(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   switch(libp->paran) {
   case 4:
      G__setnull(result7);
      ((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]));
      break;
   case 3:
      G__setnull(result7);
      ((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]));
      break;
   case 2:
      G__setnull(result7);
      ((TGeoManager*)(G__getstructoffset()))->SetBombFactors((Double_t)G__double(libp->para[0]),(Double_t)G__double(libp->para[1]));
      break;
   case 1:
      G__setnull(result7);
      ((TGeoManager*)(G__getstructoffset()))->SetBombFactors((Double_t)G__double(libp->para[0]));
      break;
   case 0:
      G__setnull(result7);
      ((TGeoManager*)(G__getstructoffset()))->SetBombFactors();
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_177_2_6(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoManager*)(G__getstructoffset()))->SetPaintVolume((TGeoVolume*)G__int(libp->para[0]));
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__Geom1_177_4_6(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   switch(libp->paran) {
   case 2:
      G__setnull(result7);
      ((TGeoManager*)(G__getstructoffset()))->SetTminTmax((Double_t)G__double(libp->para[0]),(Double_t)G__double(libp->para[1]));
      break;
   case 1:
      G__setnull(result7);
      ((TGeoManager*)(G__getstructoffset()))->SetTminTmax((Double_t)G__double(libp->para[0]));
      break;
   case 0:
      G__setnull(result7);
      ((TGeoManager*)(G__getstructoffset()))->SetTminTmax();
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__Geom1_177_6_6(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   switch(libp->paran) {
   case 1:
      G__setnull(result7);
      ((TGeoManager*)(G__getstructoffset()))->SetVisDensity((Double_t)G__double(libp->para[0]));
      break;
   case 0:
      G__setnull(result7);
      ((TGeoManager*)(G__getstructoffset()))->SetVisDensity();
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

static int G__G__Geom1_177_9_6(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   switch(libp->paran) {
   case 1:
      G__setnull(result7);
      ((TGeoManager*)(G__getstructoffset()))->ViewLeaves((Bool_t)G__int(libp->para[0]));
      break;
   case 0:
      G__setnull(result7);
      ((TGeoManager*)(G__getstructoffset()))->ViewLeaves();
      break;
   }
   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 1:
      G__setnull(result7);
      ((TGeoManager*)(G__getstructoffset()))->SaveAttributes((const char*)G__int(libp->para[0]));
      break;
   case 0:
      G__setnull(result7);
      ((TGeoManager*)(G__getstructoffset()))->SaveAttributes();
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

static int G__G__Geom1_177_3_7(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   switch(libp->paran) {
   case 4:
      G__setnull(result7);
      ((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]));
      break;
   case 3:
      G__setnull(result7);
      ((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]));
      break;
   case 2:
      G__setnull(result7);
      ((TGeoManager*)(G__getstructoffset()))->AnimateTracks((Double_t)G__double(libp->para[0]),(Double_t)G__double(libp->para[1]));
      break;
   case 1:
      G__setnull(result7);
      ((TGeoManager*)(G__getstructoffset()))->AnimateTracks((Double_t)G__double(libp->para[0]));
      break;
   case 0:
      G__setnull(result7);
      ((TGeoManager*)(G__getstructoffset()))->AnimateTracks();
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__Geom1_177_5_7(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   switch(libp->paran) {
   case 2:
      G__setnull(result7);
      ((TGeoManager*)(G__getstructoffset()))->CheckOverlaps((Double_t)G__double(libp->para[0]),(Option_t*)G__int(libp->para[1]));
      break;
   case 1:
      G__setnull(result7);
      ((TGeoManager*)(G__getstructoffset()))->CheckOverlaps((Double_t)G__double(libp->para[0]));
      break;
   case 0:
      G__setnull(result7);
      ((TGeoManager*)(G__getstructoffset()))->CheckOverlaps();
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_177_6_7(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   switch(libp->paran) {
   case 4:
      G__setnull(result7);
      ((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]));
      break;
   case 3:
      G__setnull(result7);
      ((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]));
      break;
   case 2:
      G__setnull(result7);
      ((TGeoManager*)(G__getstructoffset()))->CheckPoint((Double_t)G__double(libp->para[0]),(Double_t)G__double(libp->para[1]));
      break;
   case 1:
      G__setnull(result7);
      ((TGeoManager*)(G__getstructoffset()))->CheckPoint((Double_t)G__double(libp->para[0]));
      break;
   case 0:
      G__setnull(result7);
      ((TGeoManager*)(G__getstructoffset()))->CheckPoint();
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

static int G__G__Geom1_177_9_7(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoManager*)(G__getstructoffset()))->SetParticleName((const char*)G__int(libp->para[0]));
   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) {
   G__letint(result7,67,(long)((const TGeoManager*)(G__getstructoffset()))->GetParticleName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_177_1_8(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoManager*)(G__getstructoffset()))->DrawPath((const char*)G__int(libp->para[0]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_177_2_8(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((const TGeoManager*)(G__getstructoffset()))->PrintOverlaps();
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_177_3_8(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   switch(libp->paran) {
   case 3:
      G__setnull(result7);
      ((TGeoManager*)(G__getstructoffset()))->RandomPoints((const TGeoVolume*)G__int(libp->para[0]),(Int_t)G__int(libp->para[1])
,(Option_t*)G__int(libp->para[2]));
      break;
   case 2:
      G__setnull(result7);
      ((TGeoManager*)(G__getstructoffset()))->RandomPoints((const TGeoVolume*)G__int(libp->para[0]),(Int_t)G__int(libp->para[1]));
      break;
   case 1:
      G__setnull(result7);
      ((TGeoManager*)(G__getstructoffset()))->RandomPoints((const TGeoVolume*)G__int(libp->para[0]));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_177_4_8(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   switch(libp->paran) {
   case 4:
      G__setnull(result7);
      ((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]));
      break;
   case 3:
      G__setnull(result7);
      ((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]));
      break;
   case 2:
      G__setnull(result7);
      ((TGeoManager*)(G__getstructoffset()))->RandomRays((Int_t)G__int(libp->para[0]),(Double_t)G__double(libp->para[1]));
      break;
   case 1:
      G__setnull(result7);
      ((TGeoManager*)(G__getstructoffset()))->RandomRays((Int_t)G__int(libp->para[0]));
      break;
   case 0:
      G__setnull(result7);
      ((TGeoManager*)(G__getstructoffset()))->RandomRays();
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_177_5_8(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_177_6_8(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   switch(libp->paran) {
   case 2:
      G__setnull(result7);
      ((TGeoManager*)(G__getstructoffset()))->Test((Int_t)G__int(libp->para[0]),(Option_t*)G__int(libp->para[1]));
      break;
   case 1:
      G__setnull(result7);
      ((TGeoManager*)(G__getstructoffset()))->Test((Int_t)G__int(libp->para[0]));
      break;
   case 0:
      G__setnull(result7);
      ((TGeoManager*)(G__getstructoffset()))->Test();
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__Geom1_177_8_8(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_177_9_8(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_177_0_9(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((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]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_177_1_9(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_177_2_9(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_177_3_9(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_177_4_9(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_177_5_9(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   switch(libp->paran) {
   case 10:
      G__setnull(result7);
      ((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]));
      break;
   case 9:
      G__setnull(result7);
      ((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]));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_177_6_9(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   switch(libp->paran) {
   case 10:
      G__setnull(result7);
      ((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]));
      break;
   case 9:
      G__setnull(result7);
      ((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]));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_177_7_9(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_177_8_9(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_177_9_9(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((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]));
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

static int G__G__Geom1_177_2_10(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_177_3_10(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]),(const 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]),(const 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_177_4_10(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]),(const 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_177_5_10(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]),(const 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_177_6_10(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]),(const 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_177_7_10(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]),(const 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_177_8_10(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]),(const 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_177_9_10(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]),(const 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_177_0_11(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]),(const 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_177_1_11(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]),(const 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_177_2_11(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]),(const 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_177_3_11(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]),(const 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_177_4_11(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]),(const 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_177_5_11(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]),(const 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]),(const 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]),(const 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]),(const 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]),(const 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_177_6_11(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]),(const 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]),(const 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]),(const 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_177_7_11(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]),(const 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_177_8_11(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]),(const 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_177_9_11(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]),(const 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_177_0_12(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]),(const 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_177_1_12(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]),(const 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_177_2_12(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]),(const TGeoMedium*)G__int(libp->para[1])
,(Int_t)G__int(libp->para[2])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_177_3_12(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_177_4_12(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   switch(libp->paran) {
   case 1:
      G__setnull(result7);
      ((TGeoManager*)(G__getstructoffset()))->ClearPhysicalNodes((Bool_t)G__int(libp->para[0]));
      break;
   case 0:
      G__setnull(result7);
      ((TGeoManager*)(G__getstructoffset()))->ClearPhysicalNodes();
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_177_5_12(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_177_6_12(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_177_7_12(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]),(const TGeoMedium*)G__int(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_177_8_12(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoManager*)(G__getstructoffset()))->SetTopVolume((TGeoVolume*)G__int(libp->para[0]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_177_9_12(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()))->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_177_0_13(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()))->FindNextDaughterBoundary((Double_t*)G__int(libp->para[0]),(Double_t*)G__int(libp->para[1])
,(Bool_t)G__int(libp->para[2])));
      break;
   case 2:
   G__letint(result7,85,(long)((TGeoManager*)(G__getstructoffset()))->FindNextDaughterBoundary((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_177_1_13(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_177_2_13(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_177_3_13(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_177_4_13(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_177_5_13(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_177_6_13(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_177_7_13(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_177_8_13(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]),(const 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_177_9_13(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_177_0_14(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoManager*)(G__getstructoffset()))->SetCurrentTrack((Int_t)G__int(libp->para[0]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_177_1_14(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoManager*)(G__getstructoffset()))->SetCurrentTrack((TVirtualGeoTrack*)G__int(libp->para[0]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_177_2_14(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_177_3_14(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_177_4_14(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_177_5_14(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_177_6_14(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_177_7_14(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_177_8_14(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_177_9_14(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_177_0_15(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_177_1_15(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_177_2_15(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_177_3_15(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_177_4_15(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_177_5_15(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_177_6_15(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_177_7_15(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_177_8_15(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_177_9_15(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_177_0_16(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_177_1_16(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_177_2_16(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_177_3_16(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   switch(libp->paran) {
   case 1:
      G__setnull(result7);
      ((TGeoManager*)(G__getstructoffset()))->SetStartSafe((Bool_t)G__int(libp->para[0]));
      break;
   case 0:
      G__setnull(result7);
      ((TGeoManager*)(G__getstructoffset()))->SetStartSafe();
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

static int G__G__Geom1_177_6_16(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoManager*)(G__getstructoffset()))->SetStep((Double_t)G__double(libp->para[0]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_177_7_16(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_177_8_16(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_177_9_16(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_177_0_17(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_177_1_17(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_177_2_17(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_177_3_17(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_177_4_17(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_177_5_17(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   switch(libp->paran) {
   case 1:
      G__setnull(result7);
      ((TGeoManager*)(G__getstructoffset()))->SetOutside((Bool_t)G__int(libp->para[0]));
      break;
   case 0:
      G__setnull(result7);
      ((TGeoManager*)(G__getstructoffset()))->SetOutside();
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_177_6_17(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoManager*)(G__getstructoffset()))->UpdateCurrentPosition((Double_t*)G__int(libp->para[0]));
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__Geom1_177_8_17(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoManager*)(G__getstructoffset()))->ClearShape((const TGeoShape*)G__int(libp->para[0]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_177_9_17(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoManager*)(G__getstructoffset()))->ClearTracks();
   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__setnull(result7);
      ((TGeoManager*)(G__getstructoffset()))->RemoveMaterial((Int_t)G__int(libp->para[0]));
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__Geom1_177_2_18(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((const 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((const 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((const 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_177_3_18(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_177_4_18(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_177_5_18(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_177_6_18(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_177_7_18(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_177_8_18(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoManager*)(G__getstructoffset()))->SetAllIndex();
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_177_9_18(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_177_0_19(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_177_1_19(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_177_2_19(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_177_3_19(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_177_4_19(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_177_5_19(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_177_6_19(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_177_7_19(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_177_8_19(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_177_9_19(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_177_0_20(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_177_1_20(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_177_2_20(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_177_3_20(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   G__letint(result7,85,(long)((const TGeoManager*)(G__getstructoffset()))->GetElementTable());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_177_4_20(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_177_5_20(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_177_6_20(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_177_7_20(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_177_8_20(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_177_9_20(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_177_0_21(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_177_1_21(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_177_2_21(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_177_3_21(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_177_4_21(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_177_5_21(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_177_6_21(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_177_7_21(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_177_8_21(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_177_9_21(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_177_0_22(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_177_1_22(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_177_2_22(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_177_3_22(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_177_4_22(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_177_5_22(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_177_6_22(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoManager*)(G__getstructoffset()))->SetCurrentPoint((Double_t*)G__int(libp->para[0]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_177_7_22(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((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]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_177_8_22(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((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]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_177_9_22(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoManager*)(G__getstructoffset()))->SetCurrentDirection((Double_t*)G__int(libp->para[0]));
   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__setnull(result7);
      ((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]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_177_1_23(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoManager*)(G__getstructoffset()))->SetCldirChecked((Double_t*)G__int(libp->para[0]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_177_2_23(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((const TGeoManager*)(G__getstructoffset()))->LocalToMaster((const 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_177_3_23(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((const TGeoManager*)(G__getstructoffset()))->LocalToMasterVect((const 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_177_4_23(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((const TGeoManager*)(G__getstructoffset()))->LocalToMasterBomb((const 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_177_5_23(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((const TGeoManager*)(G__getstructoffset()))->MasterToLocal((const 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_177_6_23(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((const TGeoManager*)(G__getstructoffset()))->MasterToLocalVect((const 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_177_7_23(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((const TGeoManager*)(G__getstructoffset()))->MasterToLocalBomb((const 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_177_8_23(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((const TGeoManager*)(G__getstructoffset()))->MasterToTop((const 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_177_9_23(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((const TGeoManager*)(G__getstructoffset()))->TopToMaster((const 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_177_0_24(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   G__letint(result7,85,(long)((const TGeoManager*)(G__getstructoffset()))->FindDuplicateMaterial((const TGeoMaterial*)G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_177_1_24(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_177_2_24(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_177_3_24(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_177_4_24(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_177_5_24(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_177_6_24(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_177_7_24(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_177_8_24(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_177_9_24(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_177_0_25(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_177_1_25(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoManager*)(G__getstructoffset()))->SetCache((const TGeoNodeCache*)G__int(libp->para[0]));
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__Geom1_177_3_25(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__letint(result7,107,(long)((TGeoManager*)(G__getstructoffset()))->SizeOf((const TGeoNode*)G__int(libp->para[0]),(Option_t*)G__int(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__Geom1_177_5_25(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_177_6_25(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_177_7_25(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_177_8_25(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_177_9_25(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_177_0_26(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_177_1_26(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   switch(libp->paran) {
   case 1:
      G__setnull(result7);
      ((TGeoManager*)(G__getstructoffset()))->PopDummy((Int_t)G__int(libp->para[0]));
      break;
   case 0:
      G__setnull(result7);
      ((TGeoManager*)(G__getstructoffset()))->PopDummy();
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_177_2_26(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_177_3_26(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_177_4_26(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_177_5_26(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      TGeoManager::Dictionary();
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__Geom1_177_7_26(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoManager*)(G__getstructoffset()))->ShowMembers(*(TMemberInspector*)libp->para[0].ref,(char*)G__int(libp->para[1]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_177_8_26(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoManager*)(G__getstructoffset()))->Streamer(*(TBuffer*)libp->para[0].ref);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_177_9_26(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoManager*)(G__getstructoffset()))->StreamerNVirtual(*(TBuffer*)libp->para[0].ref);
   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,67,(long)TGeoManager::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_177_1_27(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_177_2_27(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_177_3_27(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 copy constructor
static int G__G__Geom1_177_4_27(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash)
{
   TGeoManager *p;
   void *xtmp = (void*)G__int(libp->para[0]);
   p=new TGeoManager(*(TGeoManager*)xtmp);
   result7->obj.i = (long)p;
   result7->ref = (long)p;
   result7->type = 'u';
   result7->tagnum = G__get_linked_tagnum(&G__G__Geom1LN_TGeoManager);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGeoManager G__TTGeoManager;
static int G__G__Geom1_177_5_27(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   if(0==G__getstructoffset()) return(1);
   if(G__getaryconstruct())
     if(G__PVOID==G__getgvp())
       delete[] (TGeoManager *)(G__getstructoffset());
     else
       for(int i=G__getaryconstruct()-1;i>=0;i--)
         delete (TGeoManager *)((G__getstructoffset())+sizeof(TGeoManager)*i);
   else  delete (TGeoManager *)(G__getstructoffset());
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__G__Geom1_177_6_27(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   TGeoManager *dest = (TGeoManager*)(G__getstructoffset());
   *dest = (*(TGeoManager*)libp->para[0].ref);
   const TGeoManager& obj = *dest;
   result7->ref=(long)(&obj); result7->obj.i=(long)(&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGeoVolumeMulti */
static int G__G__Geom1_179_1_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   TGeoVolumeMulti *p=NULL;
   if(G__getaryconstruct()) p=new TGeoVolumeMulti[G__getaryconstruct()];
   else                    p=new TGeoVolumeMulti;
      result7->obj.i = (long)p;
      result7->ref = (long)p;
      result7->type = 'u';
      result7->tagnum = G__get_linked_tagnum(&G__G__Geom1LN_TGeoVolumeMulti);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_179_2_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   TGeoVolumeMulti *p=NULL;
   switch(libp->paran) {
   case 2:
      p = new TGeoVolumeMulti((const char*)G__int(libp->para[0]),(const TGeoMedium*)G__int(libp->para[1]));
      break;
   case 1:
      p = new TGeoVolumeMulti((const char*)G__int(libp->para[0]));
      break;
   }
      result7->obj.i = (long)p;
      result7->ref = (long)p;
      result7->type = 'u';
      result7->tagnum = G__get_linked_tagnum(&G__G__Geom1LN_TGeoVolumeMulti);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_179_3_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoVolumeMulti*)(G__getstructoffset()))->AddVolume((TGeoVolume*)G__int(libp->para[0]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_179_4_0(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_179_5_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   switch(libp->paran) {
   case 4:
      G__setnull(result7);
      ((TGeoVolumeMulti*)(G__getstructoffset()))->AddNode((const 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]));
      break;
   case 3:
      G__setnull(result7);
      ((TGeoVolumeMulti*)(G__getstructoffset()))->AddNode((const TGeoVolume*)G__int(libp->para[0]),(Int_t)G__int(libp->para[1])
,(TGeoMatrix*)G__int(libp->para[2]));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_179_6_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   switch(libp->paran) {
   case 4:
      G__setnull(result7);
      ((TGeoVolumeMulti*)(G__getstructoffset()))->AddNodeOverlap((const 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]));
      break;
   case 3:
      G__setnull(result7);
      ((TGeoVolumeMulti*)(G__getstructoffset()))->AddNodeOverlap((const TGeoVolume*)G__int(libp->para[0]),(Int_t)G__int(libp->para[1])
,(TGeoMatrix*)G__int(libp->para[2]));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_179_7_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   switch(libp->paran) {
   case 7:
   G__letint(result7,85,(long)((TGeoVolumeMulti*)(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)((TGeoVolumeMulti*)(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)((TGeoVolumeMulti*)(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_179_8_0(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_179_9_0(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_179_0_1(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_179_1_1(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_179_2_1(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_179_3_1(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_179_4_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__letint(result7,103,(long)((const TGeoVolumeMulti*)(G__getstructoffset()))->IsVolumeMulti());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_179_5_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   G__letint(result7,85,(long)((TGeoVolumeMulti*)(G__getstructoffset()))->MakeCopyVolume((TGeoShape*)G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_179_6_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoVolumeMulti*)(G__getstructoffset()))->SetLineColor((Color_t)G__int(libp->para[0]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_179_7_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoVolumeMulti*)(G__getstructoffset()))->SetLineStyle((Style_t)G__int(libp->para[0]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_179_8_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoVolumeMulti*)(G__getstructoffset()))->SetLineWidth((Width_t)G__int(libp->para[0]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_179_9_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoVolumeMulti*)(G__getstructoffset()))->SetMedium((const TGeoMedium*)G__int(libp->para[0]));
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__Geom1_179_1_2(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_179_2_2(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_179_3_2(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_179_4_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      TGeoVolumeMulti::Dictionary();
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__Geom1_179_6_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoVolumeMulti*)(G__getstructoffset()))->ShowMembers(*(TMemberInspector*)libp->para[0].ref,(char*)G__int(libp->para[1]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_179_7_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoVolumeMulti*)(G__getstructoffset()))->Streamer(*(TBuffer*)libp->para[0].ref);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_179_8_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoVolumeMulti*)(G__getstructoffset()))->StreamerNVirtual(*(TBuffer*)libp->para[0].ref);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_179_9_2(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_179_0_3(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_179_1_3(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_179_2_3(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 copy constructor
static int G__G__Geom1_179_3_3(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash)
{
   TGeoVolumeMulti *p;
   void *xtmp = (void*)G__int(libp->para[0]);
   p=new TGeoVolumeMulti(*(TGeoVolumeMulti*)xtmp);
   result7->obj.i = (long)p;
   result7->ref = (long)p;
   result7->type = 'u';
   result7->tagnum = G__get_linked_tagnum(&G__G__Geom1LN_TGeoVolumeMulti);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGeoVolumeMulti G__TTGeoVolumeMulti;
static int G__G__Geom1_179_4_3(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   if(0==G__getstructoffset()) return(1);
   if(G__getaryconstruct())
     if(G__PVOID==G__getgvp())
       delete[] (TGeoVolumeMulti *)(G__getstructoffset());
     else
       for(int i=G__getaryconstruct()-1;i>=0;i--)
         delete (TGeoVolumeMulti *)((G__getstructoffset())+sizeof(TGeoVolumeMulti)*i);
   else  delete (TGeoVolumeMulti *)(G__getstructoffset());
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__G__Geom1_179_5_3(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   TGeoVolumeMulti *dest = (TGeoVolumeMulti*)(G__getstructoffset());
   *dest = (*(TGeoVolumeMulti*)libp->para[0].ref);
   const TGeoVolumeMulti& obj = *dest;
   result7->ref=(long)(&obj); result7->obj.i=(long)(&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGeoVolumeAssembly */
static int G__G__Geom1_180_1_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   TGeoVolumeAssembly *p=NULL;
   if(G__getaryconstruct()) p=new TGeoVolumeAssembly[G__getaryconstruct()];
   else                    p=new TGeoVolumeAssembly;
      result7->obj.i = (long)p;
      result7->ref = (long)p;
      result7->type = 'u';
      result7->tagnum = G__get_linked_tagnum(&G__G__Geom1LN_TGeoVolumeAssembly);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_180_2_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   TGeoVolumeAssembly *p=NULL;
      p = new TGeoVolumeAssembly((const char*)G__int(libp->para[0]));
      result7->obj.i = (long)p;
      result7->ref = (long)p;
      result7->type = 'u';
      result7->tagnum = G__get_linked_tagnum(&G__G__Geom1LN_TGeoVolumeAssembly);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_180_3_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__letint(result7,103,(long)((const TGeoVolumeAssembly*)(G__getstructoffset()))->IsAssembly());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_180_4_0(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_180_5_0(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_180_6_0(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_180_7_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      TGeoVolumeAssembly::Dictionary();
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__Geom1_180_9_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoVolumeAssembly*)(G__getstructoffset()))->ShowMembers(*(TMemberInspector*)libp->para[0].ref,(char*)G__int(libp->para[1]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_180_0_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoVolumeAssembly*)(G__getstructoffset()))->Streamer(*(TBuffer*)libp->para[0].ref);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_180_1_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoVolumeAssembly*)(G__getstructoffset()))->StreamerNVirtual(*(TBuffer*)libp->para[0].ref);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_180_2_1(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_180_3_1(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_180_4_1(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_180_5_1(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_180_6_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash)
{
   TGeoVolumeAssembly *p;
   void *xtmp = (void*)G__int(libp->para[0]);
   p=new TGeoVolumeAssembly(*(TGeoVolumeAssembly*)xtmp);
   result7->obj.i = (long)p;
   result7->ref = (long)p;
   result7->type = 'u';
   result7->tagnum = 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_180_7_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   if(0==G__getstructoffset()) return(1);
   if(G__getaryconstruct())
     if(G__PVOID==G__getgvp())
       delete[] (TGeoVolumeAssembly *)(G__getstructoffset());
     else
       for(int i=G__getaryconstruct()-1;i>=0;i--)
         delete (TGeoVolumeAssembly *)((G__getstructoffset())+sizeof(TGeoVolumeAssembly)*i);
   else  delete (TGeoVolumeAssembly *)(G__getstructoffset());
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__G__Geom1_180_8_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   TGeoVolumeAssembly *dest = (TGeoVolumeAssembly*)(G__getstructoffset());
   *dest = (*(TGeoVolumeAssembly*)libp->para[0].ref);
   const TGeoVolumeAssembly& obj = *dest;
   result7->ref=(long)(&obj); result7->obj.i=(long)(&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGeoCylVoxels */
static int G__G__Geom1_195_1_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   TGeoCylVoxels *p=NULL;
   if(G__getaryconstruct()) p=new TGeoCylVoxels[G__getaryconstruct()];
   else                    p=new TGeoCylVoxels;
      result7->obj.i = (long)p;
      result7->ref = (long)p;
      result7->type = 'u';
      result7->tagnum = G__get_linked_tagnum(&G__G__Geom1LN_TGeoCylVoxels);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_195_2_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   TGeoCylVoxels *p=NULL;
      p = new TGeoCylVoxels((TGeoVolume*)G__int(libp->para[0]));
      result7->obj.i = (long)p;
      result7->ref = (long)p;
      result7->type = 'u';
      result7->tagnum = G__get_linked_tagnum(&G__G__Geom1LN_TGeoCylVoxels);
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__Geom1_195_4_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__letdouble(result7,100,(double)((TGeoCylVoxels*)(G__getstructoffset()))->Efficiency());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_195_5_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((const TGeoCylVoxels*)(G__getstructoffset()))->FindOverlaps((Int_t)G__int(libp->para[0]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_195_6_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   G__letint(result7,73,(long)((TGeoCylVoxels*)(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_195_7_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   G__letint(result7,73,(long)((TGeoCylVoxels*)(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_195_8_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__letint(result7,105,(long)((const TGeoCylVoxels*)(G__getstructoffset()))->IntersectIntervals((Double_t)G__double(libp->para[0]),(Double_t)G__double(libp->para[1])
,(Double_t)G__double(libp->para[2]),(Double_t)G__double(libp->para[3])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_195_9_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   switch(libp->paran) {
   case 1:
      G__setnull(result7);
      ((const TGeoCylVoxels*)(G__getstructoffset()))->Print((Option_t*)G__int(libp->para[0]));
      break;
   case 0:
      G__setnull(result7);
      ((const TGeoCylVoxels*)(G__getstructoffset()))->Print();
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__Geom1_195_1_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoCylVoxels*)(G__getstructoffset()))->Voxelize((Option_t*)G__int(libp->para[0]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_195_2_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   G__letint(result7,85,(long)TGeoCylVoxels::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_195_3_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   G__letint(result7,67,(long)TGeoCylVoxels::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_195_4_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__letint(result7,115,(long)TGeoCylVoxels::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_195_5_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      TGeoCylVoxels::Dictionary();
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__Geom1_195_7_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoCylVoxels*)(G__getstructoffset()))->ShowMembers(*(TMemberInspector*)libp->para[0].ref,(char*)G__int(libp->para[1]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_195_8_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoCylVoxels*)(G__getstructoffset()))->Streamer(*(TBuffer*)libp->para[0].ref);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_195_9_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoCylVoxels*)(G__getstructoffset()))->StreamerNVirtual(*(TBuffer*)libp->para[0].ref);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_195_0_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   G__letint(result7,67,(long)TGeoCylVoxels::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_195_1_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__letint(result7,105,(long)TGeoCylVoxels::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_195_2_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   G__letint(result7,67,(long)TGeoCylVoxels::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_195_3_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__letint(result7,105,(long)TGeoCylVoxels::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__G__Geom1_195_4_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash)
{
   TGeoCylVoxels *p;
   void *xtmp = (void*)G__int(libp->para[0]);
   p=new TGeoCylVoxels(*(TGeoCylVoxels*)xtmp);
   result7->obj.i = (long)p;
   result7->ref = (long)p;
   result7->type = 'u';
   result7->tagnum = G__get_linked_tagnum(&G__G__Geom1LN_TGeoCylVoxels);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGeoCylVoxels G__TTGeoCylVoxels;
static int G__G__Geom1_195_5_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   if(0==G__getstructoffset()) return(1);
   if(G__getaryconstruct())
     if(G__PVOID==G__getgvp())
       delete[] (TGeoCylVoxels *)(G__getstructoffset());
     else
       for(int i=G__getaryconstruct()-1;i>=0;i--)
         delete (TGeoCylVoxels *)((G__getstructoffset())+sizeof(TGeoCylVoxels)*i);
   else  delete (TGeoCylVoxels *)(G__getstructoffset());
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__G__Geom1_195_6_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   TGeoCylVoxels *dest = (TGeoCylVoxels*)(G__getstructoffset());
   *dest = (*(TGeoCylVoxels*)libp->para[0].ref);
   const TGeoCylVoxels& obj = *dest;
   result7->ref=(long)(&obj); result7->obj.i=(long)(&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGeoFullVoxels */
static int G__G__Geom1_196_1_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   TGeoFullVoxels *p=NULL;
   if(G__getaryconstruct()) p=new TGeoFullVoxels[G__getaryconstruct()];
   else                    p=new TGeoFullVoxels;
      result7->obj.i = (long)p;
      result7->ref = (long)p;
      result7->type = 'u';
      result7->tagnum = G__get_linked_tagnum(&G__G__Geom1LN_TGeoFullVoxels);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_196_2_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   TGeoFullVoxels *p=NULL;
      p = new TGeoFullVoxels((TGeoVolume*)G__int(libp->para[0]));
      result7->obj.i = (long)p;
      result7->ref = (long)p;
      result7->type = 'u';
      result7->tagnum = G__get_linked_tagnum(&G__G__Geom1LN_TGeoFullVoxels);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_196_3_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   G__letint(result7,73,(long)((TGeoFullVoxels*)(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_196_4_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   G__letint(result7,66,(long)((const TGeoFullVoxels*)(G__getstructoffset()))->GetVoxel((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_196_5_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   G__letint(result7,73,(long)((TGeoFullVoxels*)(G__getstructoffset()))->GetVoxelCandidates((Int_t)G__int(libp->para[0]),(Int_t)G__int(libp->para[1])
,(Int_t)G__int(libp->para[2]),*(Int_t*)G__Intref(&libp->para[3])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_196_6_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   switch(libp->paran) {
   case 1:
      G__setnull(result7);
      ((const TGeoFullVoxels*)(G__getstructoffset()))->Print((Option_t*)G__int(libp->para[0]));
      break;
   case 0:
      G__setnull(result7);
      ((const TGeoFullVoxels*)(G__getstructoffset()))->Print();
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_196_7_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoFullVoxels*)(G__getstructoffset()))->Voxelize((Option_t*)G__int(libp->para[0]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_196_8_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   G__letint(result7,85,(long)TGeoFullVoxels::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_196_9_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   G__letint(result7,67,(long)TGeoFullVoxels::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_196_0_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__letint(result7,115,(long)TGeoFullVoxels::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_196_1_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      TGeoFullVoxels::Dictionary();
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__Geom1_196_3_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoFullVoxels*)(G__getstructoffset()))->ShowMembers(*(TMemberInspector*)libp->para[0].ref,(char*)G__int(libp->para[1]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_196_4_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoFullVoxels*)(G__getstructoffset()))->Streamer(*(TBuffer*)libp->para[0].ref);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_196_5_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoFullVoxels*)(G__getstructoffset()))->StreamerNVirtual(*(TBuffer*)libp->para[0].ref);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_196_6_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   G__letint(result7,67,(long)TGeoFullVoxels::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_196_7_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__letint(result7,105,(long)TGeoFullVoxels::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_196_8_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   G__letint(result7,67,(long)TGeoFullVoxels::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_196_9_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__letint(result7,105,(long)TGeoFullVoxels::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__G__Geom1_196_0_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash)
{
   TGeoFullVoxels *p;
   void *xtmp = (void*)G__int(libp->para[0]);
   p=new TGeoFullVoxels(*(TGeoFullVoxels*)xtmp);
   result7->obj.i = (long)p;
   result7->ref = (long)p;
   result7->type = 'u';
   result7->tagnum = G__get_linked_tagnum(&G__G__Geom1LN_TGeoFullVoxels);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGeoFullVoxels G__TTGeoFullVoxels;
static int G__G__Geom1_196_1_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   if(0==G__getstructoffset()) return(1);
   if(G__getaryconstruct())
     if(G__PVOID==G__getgvp())
       delete[] (TGeoFullVoxels *)(G__getstructoffset());
     else
       for(int i=G__getaryconstruct()-1;i>=0;i--)
         delete (TGeoFullVoxels *)((G__getstructoffset())+sizeof(TGeoFullVoxels)*i);
   else  delete (TGeoFullVoxels *)(G__getstructoffset());
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__G__Geom1_196_2_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   TGeoFullVoxels *dest = (TGeoFullVoxels*)(G__getstructoffset());
   *dest = (*(TGeoFullVoxels*)libp->para[0].ref);
   const TGeoFullVoxels& obj = *dest;
   result7->ref=(long)(&obj); result7->obj.i=(long)(&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGeoNodeMatrix */
static int G__G__Geom1_198_1_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   TGeoNodeMatrix *p=NULL;
   if(G__getaryconstruct()) p=new TGeoNodeMatrix[G__getaryconstruct()];
   else                    p=new TGeoNodeMatrix;
      result7->obj.i = (long)p;
      result7->ref = (long)p;
      result7->type = 'u';
      result7->tagnum = G__get_linked_tagnum(&G__G__Geom1LN_TGeoNodeMatrix);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_198_2_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   TGeoNodeMatrix *p=NULL;
      p = new TGeoNodeMatrix((const TGeoVolume*)G__int(libp->para[0]),(const TGeoMatrix*)G__int(libp->para[1]));
      result7->obj.i = (long)p;
      result7->ref = (long)p;
      result7->type = 'u';
      result7->tagnum = G__get_linked_tagnum(&G__G__Geom1LN_TGeoNodeMatrix);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_198_3_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__letint(result7,105,(long)((const TGeoNodeMatrix*)(G__getstructoffset()))->GetByteCount());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_198_4_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__letint(result7,105,(long)((const TGeoNodeMatrix*)(G__getstructoffset()))->GetOptimalVoxels());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_198_5_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__letint(result7,103,(long)((const TGeoNodeMatrix*)(G__getstructoffset()))->IsFolder());
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

static int G__G__Geom1_198_8_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoNodeMatrix*)(G__getstructoffset()))->SetMatrix((const TGeoMatrix*)G__int(libp->para[0]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_198_9_0(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_198_0_1(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_198_1_1(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_198_2_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      TGeoNodeMatrix::Dictionary();
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__Geom1_198_4_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoNodeMatrix*)(G__getstructoffset()))->ShowMembers(*(TMemberInspector*)libp->para[0].ref,(char*)G__int(libp->para[1]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_198_5_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoNodeMatrix*)(G__getstructoffset()))->Streamer(*(TBuffer*)libp->para[0].ref);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_198_6_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoNodeMatrix*)(G__getstructoffset()))->StreamerNVirtual(*(TBuffer*)libp->para[0].ref);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_198_7_1(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_198_8_1(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_198_9_1(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_198_0_2(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 copy constructor
static int G__G__Geom1_198_1_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash)
{
   TGeoNodeMatrix *p;
   void *xtmp = (void*)G__int(libp->para[0]);
   p=new TGeoNodeMatrix(*(TGeoNodeMatrix*)xtmp);
   result7->obj.i = (long)p;
   result7->ref = (long)p;
   result7->type = 'u';
   result7->tagnum = G__get_linked_tagnum(&G__G__Geom1LN_TGeoNodeMatrix);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGeoNodeMatrix G__TTGeoNodeMatrix;
static int G__G__Geom1_198_2_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   if(0==G__getstructoffset()) return(1);
   if(G__getaryconstruct())
     if(G__PVOID==G__getgvp())
       delete[] (TGeoNodeMatrix *)(G__getstructoffset());
     else
       for(int i=G__getaryconstruct()-1;i>=0;i--)
         delete (TGeoNodeMatrix *)((G__getstructoffset())+sizeof(TGeoNodeMatrix)*i);
   else  delete (TGeoNodeMatrix *)(G__getstructoffset());
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__G__Geom1_198_3_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   TGeoNodeMatrix *dest = (TGeoNodeMatrix*)(G__getstructoffset());
   *dest = (*(TGeoNodeMatrix*)libp->para[0].ref);
   const TGeoNodeMatrix& obj = *dest;
   result7->ref=(long)(&obj); result7->obj.i=(long)(&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGeoNodeOffset */
static int G__G__Geom1_199_1_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   TGeoNodeOffset *p=NULL;
   if(G__getaryconstruct()) p=new TGeoNodeOffset[G__getaryconstruct()];
   else                    p=new TGeoNodeOffset;
      result7->obj.i = (long)p;
      result7->ref = (long)p;
      result7->type = 'u';
      result7->tagnum = G__get_linked_tagnum(&G__G__Geom1LN_TGeoNodeOffset);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_199_2_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   TGeoNodeOffset *p=NULL;
      p = new TGeoNodeOffset(
(const 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;
      result7->type = 'u';
      result7->tagnum = G__get_linked_tagnum(&G__G__Geom1LN_TGeoNodeOffset);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_199_3_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((const TGeoNodeOffset*)(G__getstructoffset()))->cd();
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_199_4_0(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_199_5_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__letint(result7,105,(long)((const TGeoNodeOffset*)(G__getstructoffset()))->GetIndex());
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

static int G__G__Geom1_199_9_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoNodeOffset*)(G__getstructoffset()))->SetFinder((const TGeoPatternFinder*)G__int(libp->para[0]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_199_0_1(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_199_1_1(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_199_2_1(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_199_3_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      TGeoNodeOffset::Dictionary();
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__Geom1_199_5_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoNodeOffset*)(G__getstructoffset()))->ShowMembers(*(TMemberInspector*)libp->para[0].ref,(char*)G__int(libp->para[1]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_199_6_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoNodeOffset*)(G__getstructoffset()))->Streamer(*(TBuffer*)libp->para[0].ref);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_199_7_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoNodeOffset*)(G__getstructoffset()))->StreamerNVirtual(*(TBuffer*)libp->para[0].ref);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_199_8_1(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_199_9_1(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_199_0_2(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_199_1_2(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 copy constructor
static int G__G__Geom1_199_2_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash)
{
   TGeoNodeOffset *p;
   void *xtmp = (void*)G__int(libp->para[0]);
   p=new TGeoNodeOffset(*(TGeoNodeOffset*)xtmp);
   result7->obj.i = (long)p;
   result7->ref = (long)p;
   result7->type = 'u';
   result7->tagnum = G__get_linked_tagnum(&G__G__Geom1LN_TGeoNodeOffset);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGeoNodeOffset G__TTGeoNodeOffset;
static int G__G__Geom1_199_3_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   if(0==G__getstructoffset()) return(1);
   if(G__getaryconstruct())
     if(G__PVOID==G__getgvp())
       delete[] (TGeoNodeOffset *)(G__getstructoffset());
     else
       for(int i=G__getaryconstruct()-1;i>=0;i--)
         delete (TGeoNodeOffset *)((G__getstructoffset())+sizeof(TGeoNodeOffset)*i);
   else  delete (TGeoNodeOffset *)(G__getstructoffset());
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__G__Geom1_199_4_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   TGeoNodeOffset *dest = (TGeoNodeOffset*)(G__getstructoffset());
   *dest = (*(TGeoNodeOffset*)libp->para[0].ref);
   const TGeoNodeOffset& obj = *dest;
   result7->ref=(long)(&obj); result7->obj.i=(long)(&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGeoPara */
static int G__G__Geom1_200_1_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   TGeoPara *p=NULL;
   if(G__getaryconstruct()) p=new TGeoPara[G__getaryconstruct()];
   else                    p=new TGeoPara;
      result7->obj.i = (long)p;
      result7->ref = (long)p;
      result7->type = 'u';
      result7->tagnum = G__get_linked_tagnum(&G__G__Geom1LN_TGeoPara);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_200_2_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   TGeoPara *p=NULL;
      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]));
      result7->obj.i = (long)p;
      result7->ref = (long)p;
      result7->type = 'u';
      result7->tagnum = G__get_linked_tagnum(&G__G__Geom1LN_TGeoPara);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_200_3_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   TGeoPara *p=NULL;
      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]));
      result7->obj.i = (long)p;
      result7->ref = (long)p;
      result7->type = 'u';
      result7->tagnum = G__get_linked_tagnum(&G__G__Geom1LN_TGeoPara);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_200_4_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   TGeoPara *p=NULL;
      p = new TGeoPara((Double_t*)G__int(libp->para[0]));
      result7->obj.i = (long)p;
      result7->ref = (long)p;
      result7->type = 'u';
      result7->tagnum = G__get_linked_tagnum(&G__G__Geom1LN_TGeoPara);
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__Geom1_200_6_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoPara*)(G__getstructoffset()))->ComputeNormal((Double_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_200_7_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__letint(result7,103,(long)((const TGeoPara*)(G__getstructoffset()))->Contains((Double_t*)G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_200_8_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   switch(libp->paran) {
   case 5:
      G__letdouble(result7,100,(double)((const TGeoPara*)(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 TGeoPara*)(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 TGeoPara*)(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 TGeoPara*)(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_200_9_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   switch(libp->paran) {
   case 5:
      G__letdouble(result7,100,(double)((const TGeoPara*)(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 TGeoPara*)(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 TGeoPara*)(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 TGeoPara*)(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_200_0_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   G__letint(result7,85,(long)((TGeoPara*)(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_200_1_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__letdouble(result7,100,(double)((const TGeoPara*)(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_200_2_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((const TGeoPara*)(G__getstructoffset()))->GetBoundingCylinder((Double_t*)G__int(libp->para[0]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_200_3_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__letint(result7,105,(long)((const TGeoPara*)(G__getstructoffset()))->GetByteCount());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_200_4_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__letint(result7,105,(long)((const TGeoPara*)(G__getstructoffset()))->GetFittingBox((const 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_200_5_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   G__letint(result7,85,(long)((const TGeoPara*)(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_200_6_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__letint(result7,105,(long)((const TGeoPara*)(G__getstructoffset()))->GetNmeshVertices());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_200_7_1(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_200_8_1(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_200_9_1(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_200_0_2(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_200_1_2(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_200_2_2(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_200_3_2(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_200_4_2(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_200_5_2(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_200_6_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((const TGeoPara*)(G__getstructoffset()))->InspectShape();
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_200_7_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__letint(result7,103,(long)((const TGeoPara*)(G__getstructoffset()))->IsCylType());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_200_8_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   switch(libp->paran) {
   case 2:
      G__letdouble(result7,100,(double)((const TGeoPara*)(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 TGeoPara*)(G__getstructoffset()))->Safety((Double_t*)G__int(libp->para[0])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_200_9_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoPara*)(G__getstructoffset()))->SavePrimitive(*(ofstream*)libp->para[0].ref,(Option_t*)G__int(libp->para[1]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_200_0_3(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoPara*)(G__getstructoffset()))->SetDimensions((Double_t*)G__int(libp->para[0]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_200_1_3(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((const TGeoPara*)(G__getstructoffset()))->SetPoints((Double_t*)G__int(libp->para[0]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_200_2_3(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((const TGeoPara*)(G__getstructoffset()))->SetPoints((Float_t*)G__int(libp->para[0]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_200_3_3(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((const TGeoPara*)(G__getstructoffset()))->Sizeof3D();
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_200_4_3(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_200_5_3(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_200_6_3(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_200_7_3(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      TGeoPara::Dictionary();
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__Geom1_200_9_3(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoPara*)(G__getstructoffset()))->ShowMembers(*(TMemberInspector*)libp->para[0].ref,(char*)G__int(libp->para[1]));
   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) {
      G__setnull(result7);
      ((TGeoPara*)(G__getstructoffset()))->Streamer(*(TBuffer*)libp->para[0].ref);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_200_1_4(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoPara*)(G__getstructoffset()))->StreamerNVirtual(*(TBuffer*)libp->para[0].ref);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_200_2_4(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_200_3_4(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_200_4_4(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_200_5_4(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_200_6_4(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash)
{
   TGeoPara *p;
   void *xtmp = (void*)G__int(libp->para[0]);
   p=new TGeoPara(*(TGeoPara*)xtmp);
   result7->obj.i = (long)p;
   result7->ref = (long)p;
   result7->type = 'u';
   result7->tagnum = 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_200_7_4(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   if(0==G__getstructoffset()) return(1);
   if(G__getaryconstruct())
     if(G__PVOID==G__getgvp())
       delete[] (TGeoPara *)(G__getstructoffset());
     else
       for(int i=G__getaryconstruct()-1;i>=0;i--)
         delete (TGeoPara *)((G__getstructoffset())+sizeof(TGeoPara)*i);
   else  delete (TGeoPara *)(G__getstructoffset());
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__G__Geom1_200_8_4(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_201_1_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   TGeoTube *p=NULL;
   if(G__getaryconstruct()) p=new TGeoTube[G__getaryconstruct()];
   else                    p=new TGeoTube;
      result7->obj.i = (long)p;
      result7->ref = (long)p;
      result7->type = 'u';
      result7->tagnum = G__get_linked_tagnum(&G__G__Geom1LN_TGeoTube);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_201_2_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   TGeoTube *p=NULL;
      p = new 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;
      result7->type = 'u';
      result7->tagnum = G__get_linked_tagnum(&G__G__Geom1LN_TGeoTube);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_201_3_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   TGeoTube *p=NULL;
      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]));
      result7->obj.i = (long)p;
      result7->ref = (long)p;
      result7->type = 'u';
      result7->tagnum = G__get_linked_tagnum(&G__G__Geom1LN_TGeoTube);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_201_4_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   TGeoTube *p=NULL;
      p = new TGeoTube((Double_t*)G__int(libp->para[0]));
      result7->obj.i = (long)p;
      result7->ref = (long)p;
      result7->type = 'u';
      result7->tagnum = G__get_linked_tagnum(&G__G__Geom1LN_TGeoTube);
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__Geom1_201_6_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoTube*)(G__getstructoffset()))->ComputeNormal((Double_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_201_7_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      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]));
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__Geom1_201_9_0(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_201_0_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   switch(libp->paran) {
   case 5:
      G__letdouble(result7,100,(double)((const TGeoTube*)(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 TGeoTube*)(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 TGeoTube*)(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 TGeoTube*)(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_201_1_1(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_201_2_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   switch(libp->paran) {
   case 5:
      G__letdouble(result7,100,(double)((const TGeoTube*)(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 TGeoTube*)(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 TGeoTube*)(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 TGeoTube*)(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_201_3_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      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]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_201_4_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__letint(result7,105,(long)((TGeoTube*)(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_201_5_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   G__letint(result7,85,(long)((TGeoTube*)(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_201_6_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   G__letint(result7,67,(long)((const TGeoTube*)(G__getstructoffset()))->GetAxisName((Int_t)G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_201_7_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__letdouble(result7,100,(double)((const TGeoTube*)(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_201_8_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((const TGeoTube*)(G__getstructoffset()))->GetBoundingCylinder((Double_t*)G__int(libp->para[0]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_201_9_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      {
        const TBuffer3D& obj=((const TGeoTube*)(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_201_0_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__letint(result7,105,(long)((const TGeoTube*)(G__getstructoffset()))->GetByteCount());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_201_1_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   G__letint(result7,85,(long)((const TGeoTube*)(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_201_2_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__letint(result7,105,(long)((const TGeoTube*)(G__getstructoffset()))->GetNmeshVertices());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_201_3_2(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_201_4_2(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_201_5_2(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_201_6_2(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_201_7_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((const TGeoTube*)(G__getstructoffset()))->InspectShape();
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_201_8_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__letint(result7,103,(long)((const TGeoTube*)(G__getstructoffset()))->IsCylType());
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__Geom1_201_0_3(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   switch(libp->paran) {
   case 2:
      G__letdouble(result7,100,(double)((const TGeoTube*)(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 TGeoTube*)(G__getstructoffset()))->Safety((Double_t*)G__int(libp->para[0])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_201_1_3(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_201_2_3(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoTube*)(G__getstructoffset()))->SavePrimitive(*(ofstream*)libp->para[0].ref,(Option_t*)G__int(libp->para[1]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_201_3_3(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((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]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_201_4_3(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoTube*)(G__getstructoffset()))->SetDimensions((Double_t*)G__int(libp->para[0]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_201_5_3(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((const TGeoTube*)(G__getstructoffset()))->SetPoints((Double_t*)G__int(libp->para[0]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_201_6_3(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((const TGeoTube*)(G__getstructoffset()))->SetPoints((Float_t*)G__int(libp->para[0]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_201_7_3(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((const TGeoTube*)(G__getstructoffset()))->SetSegsAndPols(*(TBuffer3D*)libp->para[0].ref);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_201_8_3(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((const TGeoTube*)(G__getstructoffset()))->Sizeof3D();
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_201_9_3(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_201_0_4(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_201_1_4(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_201_2_4(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      TGeoTube::Dictionary();
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__Geom1_201_4_4(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoTube*)(G__getstructoffset()))->ShowMembers(*(TMemberInspector*)libp->para[0].ref,(char*)G__int(libp->para[1]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_201_5_4(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoTube*)(G__getstructoffset()))->Streamer(*(TBuffer*)libp->para[0].ref);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_201_6_4(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoTube*)(G__getstructoffset()))->StreamerNVirtual(*(TBuffer*)libp->para[0].ref);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_201_7_4(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_201_8_4(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_201_9_4(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_201_0_5(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_201_1_5(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash)
{
   TGeoTube *p;
   void *xtmp = (void*)G__int(libp->para[0]);
   p=new TGeoTube(*(TGeoTube*)xtmp);
   result7->obj.i = (long)p;
   result7->ref = (long)p;
   result7->type = 'u';
   result7->tagnum = 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_201_2_5(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   if(0==G__getstructoffset()) return(1);
   if(G__getaryconstruct())
     if(G__PVOID==G__getgvp())
       delete[] (TGeoTube *)(G__getstructoffset());
     else
       for(int i=G__getaryconstruct()-1;i>=0;i--)
         delete (TGeoTube *)((G__getstructoffset())+sizeof(TGeoTube)*i);
   else  delete (TGeoTube *)(G__getstructoffset());
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__G__Geom1_201_3_5(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_202_1_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   TGeoTubeSeg *p=NULL;
   if(G__getaryconstruct()) p=new TGeoTubeSeg[G__getaryconstruct()];
   else                    p=new TGeoTubeSeg;
      result7->obj.i = (long)p;
      result7->ref = (long)p;
      result7->type = 'u';
      result7->tagnum = G__get_linked_tagnum(&G__G__Geom1LN_TGeoTubeSeg);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_202_2_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   TGeoTubeSeg *p=NULL;
      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]));
      result7->obj.i = (long)p;
      result7->ref = (long)p;
      result7->type = 'u';
      result7->tagnum = G__get_linked_tagnum(&G__G__Geom1LN_TGeoTubeSeg);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_202_3_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   TGeoTubeSeg *p=NULL;
      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]));
      result7->obj.i = (long)p;
      result7->ref = (long)p;
      result7->type = 'u';
      result7->tagnum = G__get_linked_tagnum(&G__G__Geom1LN_TGeoTubeSeg);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_202_4_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   TGeoTubeSeg *p=NULL;
      p = new TGeoTubeSeg((Double_t*)G__int(libp->para[0]));
      result7->obj.i = (long)p;
      result7->ref = (long)p;
      result7->type = 'u';
      result7->tagnum = G__get_linked_tagnum(&G__G__Geom1LN_TGeoTubeSeg);
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__Geom1_202_6_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoTubeSeg*)(G__getstructoffset()))->ComputeNormal((Double_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_202_7_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      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]));
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__Geom1_202_9_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__letint(result7,105,(long)((TGeoTubeSeg*)(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_202_0_1(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_202_1_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   switch(libp->paran) {
   case 5:
      G__letdouble(result7,100,(double)((const TGeoTubeSeg*)(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 TGeoTubeSeg*)(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 TGeoTubeSeg*)(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 TGeoTubeSeg*)(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_202_2_1(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_202_3_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   switch(libp->paran) {
   case 5:
      G__letdouble(result7,100,(double)((const TGeoTubeSeg*)(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 TGeoTubeSeg*)(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 TGeoTubeSeg*)(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 TGeoTubeSeg*)(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_202_4_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   G__letint(result7,85,(long)((TGeoTubeSeg*)(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_202_5_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__letdouble(result7,100,(double)((const TGeoTubeSeg*)(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_202_6_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((const TGeoTubeSeg*)(G__getstructoffset()))->GetBoundingCylinder((Double_t*)G__int(libp->para[0]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_202_7_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      {
        const TBuffer3D& obj=((const TGeoTubeSeg*)(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_202_8_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__letint(result7,105,(long)((const TGeoTubeSeg*)(G__getstructoffset()))->GetByteCount());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_202_9_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   G__letint(result7,85,(long)((const TGeoTubeSeg*)(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_202_0_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__letint(result7,105,(long)((const TGeoTubeSeg*)(G__getstructoffset()))->GetNmeshVertices());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_202_1_2(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_202_2_2(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_202_3_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((const TGeoTubeSeg*)(G__getstructoffset()))->InspectShape();
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__Geom1_202_5_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   switch(libp->paran) {
   case 2:
      G__letdouble(result7,100,(double)((const TGeoTubeSeg*)(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 TGeoTubeSeg*)(G__getstructoffset()))->Safety((Double_t*)G__int(libp->para[0])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_202_6_2(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_202_7_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoTubeSeg*)(G__getstructoffset()))->SavePrimitive(*(ofstream*)libp->para[0].ref,(Option_t*)G__int(libp->para[1]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_202_8_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((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]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_202_9_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoTubeSeg*)(G__getstructoffset()))->SetDimensions((Double_t*)G__int(libp->para[0]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_202_0_3(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((const TGeoTubeSeg*)(G__getstructoffset()))->SetPoints((Double_t*)G__int(libp->para[0]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_202_1_3(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((const TGeoTubeSeg*)(G__getstructoffset()))->SetPoints((Float_t*)G__int(libp->para[0]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_202_2_3(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((const TGeoTubeSeg*)(G__getstructoffset()))->SetSegsAndPols(*(TBuffer3D*)libp->para[0].ref);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_202_3_3(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((const TGeoTubeSeg*)(G__getstructoffset()))->Sizeof3D();
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_202_4_3(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_202_5_3(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_202_6_3(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_202_7_3(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      TGeoTubeSeg::Dictionary();
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__Geom1_202_9_3(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoTubeSeg*)(G__getstructoffset()))->ShowMembers(*(TMemberInspector*)libp->para[0].ref,(char*)G__int(libp->para[1]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_202_0_4(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoTubeSeg*)(G__getstructoffset()))->Streamer(*(TBuffer*)libp->para[0].ref);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_202_1_4(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoTubeSeg*)(G__getstructoffset()))->StreamerNVirtual(*(TBuffer*)libp->para[0].ref);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_202_2_4(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_202_3_4(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_202_4_4(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_202_5_4(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_202_6_4(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash)
{
   TGeoTubeSeg *p;
   void *xtmp = (void*)G__int(libp->para[0]);
   p=new TGeoTubeSeg(*(TGeoTubeSeg*)xtmp);
   result7->obj.i = (long)p;
   result7->ref = (long)p;
   result7->type = 'u';
   result7->tagnum = 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_202_7_4(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   if(0==G__getstructoffset()) return(1);
   if(G__getaryconstruct())
     if(G__PVOID==G__getgvp())
       delete[] (TGeoTubeSeg *)(G__getstructoffset());
     else
       for(int i=G__getaryconstruct()-1;i>=0;i--)
         delete (TGeoTubeSeg *)((G__getstructoffset())+sizeof(TGeoTubeSeg)*i);
   else  delete (TGeoTubeSeg *)(G__getstructoffset());
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__G__Geom1_202_8_4(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_203_1_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   TGeoCtub *p=NULL;
   if(G__getaryconstruct()) p=new TGeoCtub[G__getaryconstruct()];
   else                    p=new TGeoCtub;
      result7->obj.i = (long)p;
      result7->ref = (long)p;
      result7->type = 'u';
      result7->tagnum = G__get_linked_tagnum(&G__G__Geom1LN_TGeoCtub);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_203_2_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   TGeoCtub *p=NULL;
      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]));
      result7->obj.i = (long)p;
      result7->ref = (long)p;
      result7->type = 'u';
      result7->tagnum = G__get_linked_tagnum(&G__G__Geom1LN_TGeoCtub);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_203_3_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   TGeoCtub *p=NULL;
      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]));
      result7->obj.i = (long)p;
      result7->ref = (long)p;
      result7->type = 'u';
      result7->tagnum = G__get_linked_tagnum(&G__G__Geom1LN_TGeoCtub);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_203_4_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   TGeoCtub *p=NULL;
      p = new TGeoCtub((Double_t*)G__int(libp->para[0]));
      result7->obj.i = (long)p;
      result7->ref = (long)p;
      result7->type = 'u';
      result7->tagnum = G__get_linked_tagnum(&G__G__Geom1LN_TGeoCtub);
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__Geom1_203_6_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoCtub*)(G__getstructoffset()))->ComputeNormal((Double_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_203_7_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__letint(result7,103,(long)((const TGeoCtub*)(G__getstructoffset()))->Contains((Double_t*)G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_203_8_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   switch(libp->paran) {
   case 5:
      G__letdouble(result7,100,(double)((const TGeoCtub*)(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 TGeoCtub*)(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 TGeoCtub*)(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 TGeoCtub*)(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_203_9_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   switch(libp->paran) {
   case 5:
      G__letdouble(result7,100,(double)((const TGeoCtub*)(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 TGeoCtub*)(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 TGeoCtub*)(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 TGeoCtub*)(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_203_0_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   G__letint(result7,85,(long)((TGeoCtub*)(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_203_1_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__letdouble(result7,100,(double)((const TGeoCtub*)(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_203_2_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      {
        const TBuffer3D& obj=((const TGeoCtub*)(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_203_3_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__letint(result7,105,(long)((const TGeoCtub*)(G__getstructoffset()))->GetByteCount());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_203_4_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   G__letint(result7,85,(long)((const TGeoCtub*)(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_203_5_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__letint(result7,105,(long)((const TGeoCtub*)(G__getstructoffset()))->GetNmeshVertices());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_203_6_1(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_203_7_1(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_203_8_1(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_203_9_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((const TGeoCtub*)(G__getstructoffset()))->InspectShape();
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_203_0_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   switch(libp->paran) {
   case 2:
      G__letdouble(result7,100,(double)((const TGeoCtub*)(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 TGeoCtub*)(G__getstructoffset()))->Safety((Double_t*)G__int(libp->para[0])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_203_1_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoCtub*)(G__getstructoffset()))->SavePrimitive(*(ofstream*)libp->para[0].ref,(Option_t*)G__int(libp->para[1]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_203_2_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((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]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_203_3_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoCtub*)(G__getstructoffset()))->SetDimensions((Double_t*)G__int(libp->para[0]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_203_4_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((const TGeoCtub*)(G__getstructoffset()))->SetPoints((Double_t*)G__int(libp->para[0]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_203_5_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((const TGeoCtub*)(G__getstructoffset()))->SetPoints((Float_t*)G__int(libp->para[0]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_203_6_2(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_203_7_2(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_203_8_2(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_203_9_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      TGeoCtub::Dictionary();
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__Geom1_203_1_3(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoCtub*)(G__getstructoffset()))->ShowMembers(*(TMemberInspector*)libp->para[0].ref,(char*)G__int(libp->para[1]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_203_2_3(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoCtub*)(G__getstructoffset()))->Streamer(*(TBuffer*)libp->para[0].ref);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_203_3_3(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoCtub*)(G__getstructoffset()))->StreamerNVirtual(*(TBuffer*)libp->para[0].ref);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_203_4_3(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_203_5_3(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_203_6_3(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_203_7_3(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_203_8_3(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash)
{
   TGeoCtub *p;
   void *xtmp = (void*)G__int(libp->para[0]);
   p=new TGeoCtub(*(TGeoCtub*)xtmp);
   result7->obj.i = (long)p;
   result7->ref = (long)p;
   result7->type = 'u';
   result7->tagnum = 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_203_9_3(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   if(0==G__getstructoffset()) return(1);
   if(G__getaryconstruct())
     if(G__PVOID==G__getgvp())
       delete[] (TGeoCtub *)(G__getstructoffset());
     else
       for(int i=G__getaryconstruct()-1;i>=0;i--)
         delete (TGeoCtub *)((G__getstructoffset())+sizeof(TGeoCtub)*i);
   else  delete (TGeoCtub *)(G__getstructoffset());
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__G__Geom1_203_0_4(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_204_1_0(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_204_2_0(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_204_3_0(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_204_4_0(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_204_5_0(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_204_6_0(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_204_7_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   TGeoTorus *p=NULL;
   if(G__getaryconstruct()) p=new TGeoTorus[G__getaryconstruct()];
   else                    p=new TGeoTorus;
      result7->obj.i = (long)p;
      result7->ref = (long)p;
      result7->type = 'u';
      result7->tagnum = G__get_linked_tagnum(&G__G__Geom1LN_TGeoTorus);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_204_8_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   TGeoTorus *p=NULL;
   switch(libp->paran) {
   case 5:
      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]));
      break;
   case 4:
      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]));
      break;
   case 3:
      p = new 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;
      result7->type = 'u';
      result7->tagnum = G__get_linked_tagnum(&G__G__Geom1LN_TGeoTorus);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_204_9_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   TGeoTorus *p=NULL;
   switch(libp->paran) {
   case 6:
      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]));
      break;
   case 5:
      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]));
      break;
   case 4:
      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]));
      break;
   }
      result7->obj.i = (long)p;
      result7->ref = (long)p;
      result7->type = 'u';
      result7->tagnum = G__get_linked_tagnum(&G__G__Geom1LN_TGeoTorus);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_204_0_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   TGeoTorus *p=NULL;
      p = new TGeoTorus((Double_t*)G__int(libp->para[0]));
      result7->obj.i = (long)p;
      result7->ref = (long)p;
      result7->type = 'u';
      result7->tagnum = G__get_linked_tagnum(&G__G__Geom1LN_TGeoTorus);
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__Geom1_204_2_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoTorus*)(G__getstructoffset()))->ComputeNormal((Double_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_204_3_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__letint(result7,103,(long)((const TGeoTorus*)(G__getstructoffset()))->Contains((Double_t*)G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_204_4_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   switch(libp->paran) {
   case 5:
      G__letdouble(result7,100,(double)((const TGeoTorus*)(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 TGeoTorus*)(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 TGeoTorus*)(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 TGeoTorus*)(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_204_5_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   switch(libp->paran) {
   case 5:
      G__letdouble(result7,100,(double)((const TGeoTorus*)(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 TGeoTorus*)(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 TGeoTorus*)(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 TGeoTorus*)(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_204_6_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__letint(result7,105,(long)((TGeoTorus*)(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_204_7_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   G__letint(result7,85,(long)((TGeoTorus*)(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_204_8_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   G__letint(result7,67,(long)((const TGeoTorus*)(G__getstructoffset()))->GetAxisName((Int_t)G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_204_9_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__letdouble(result7,100,(double)((const TGeoTorus*)(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_204_0_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((const TGeoTorus*)(G__getstructoffset()))->GetBoundingCylinder((Double_t*)G__int(libp->para[0]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_204_1_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      {
        const TBuffer3D& obj=((const TGeoTorus*)(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_204_2_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__letint(result7,105,(long)((const TGeoTorus*)(G__getstructoffset()))->GetByteCount());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_204_3_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   G__letint(result7,85,(long)((const TGeoTorus*)(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_204_4_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__letint(result7,105,(long)((const TGeoTorus*)(G__getstructoffset()))->GetNmeshVertices());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_204_5_2(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_204_6_2(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_204_7_2(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_204_8_2(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_204_9_2(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_204_0_3(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((const TGeoTorus*)(G__getstructoffset()))->InspectShape();
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_204_1_3(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__letint(result7,103,(long)((const TGeoTorus*)(G__getstructoffset()))->IsCylType());
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__Geom1_204_3_3(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   switch(libp->paran) {
   case 2:
      G__letdouble(result7,100,(double)((const TGeoTorus*)(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 TGeoTorus*)(G__getstructoffset()))->Safety((Double_t*)G__int(libp->para[0])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_204_4_3(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoTorus*)(G__getstructoffset()))->SavePrimitive(*(ofstream*)libp->para[0].ref,(Option_t*)G__int(libp->para[1]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_204_5_3(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((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]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_204_6_3(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoTorus*)(G__getstructoffset()))->SetDimensions((Double_t*)G__int(libp->para[0]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_204_7_3(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((const TGeoTorus*)(G__getstructoffset()))->SetPoints((Double_t*)G__int(libp->para[0]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_204_8_3(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((const TGeoTorus*)(G__getstructoffset()))->SetPoints((Float_t*)G__int(libp->para[0]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_204_9_3(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((const TGeoTorus*)(G__getstructoffset()))->SetSegsAndPols(*(TBuffer3D*)libp->para[0].ref);
   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) {
      G__setnull(result7);
      ((const TGeoTorus*)(G__getstructoffset()))->Sizeof3D();
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_204_1_4(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_204_2_4(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_204_3_4(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_204_4_4(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      TGeoTorus::Dictionary();
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__Geom1_204_6_4(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoTorus*)(G__getstructoffset()))->ShowMembers(*(TMemberInspector*)libp->para[0].ref,(char*)G__int(libp->para[1]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_204_7_4(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoTorus*)(G__getstructoffset()))->Streamer(*(TBuffer*)libp->para[0].ref);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_204_8_4(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoTorus*)(G__getstructoffset()))->StreamerNVirtual(*(TBuffer*)libp->para[0].ref);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_204_9_4(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_204_0_5(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_204_1_5(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_204_2_5(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_204_3_5(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash)
{
   TGeoTorus *p;
   void *xtmp = (void*)G__int(libp->para[0]);
   p=new TGeoTorus(*(TGeoTorus*)xtmp);
   result7->obj.i = (long)p;
   result7->ref = (long)p;
   result7->type = 'u';
   result7->tagnum = 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_204_4_5(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   if(0==G__getstructoffset()) return(1);
   if(G__getaryconstruct())
     if(G__PVOID==G__getgvp())
       delete[] (TGeoTorus *)(G__getstructoffset());
     else
       for(int i=G__getaryconstruct()-1;i>=0;i--)
         delete (TGeoTorus *)((G__getstructoffset())+sizeof(TGeoTorus)*i);
   else  delete (TGeoTorus *)(G__getstructoffset());
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__G__Geom1_204_5_5(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_205_1_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   TGeoSphere *p=NULL;
   if(G__getaryconstruct()) p=new TGeoSphere[G__getaryconstruct()];
   else                    p=new TGeoSphere;
      result7->obj.i = (long)p;
      result7->ref = (long)p;
      result7->type = 'u';
      result7->tagnum = G__get_linked_tagnum(&G__G__Geom1LN_TGeoSphere);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_205_2_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   TGeoSphere *p=NULL;
   switch(libp->paran) {
   case 6:
      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]));
      break;
   case 5:
      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]));
      break;
   case 4:
      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]));
      break;
   case 3:
      p = new 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:
      p = new 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;
      result7->type = 'u';
      result7->tagnum = G__get_linked_tagnum(&G__G__Geom1LN_TGeoSphere);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_205_3_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   TGeoSphere *p=NULL;
   switch(libp->paran) {
   case 7:
      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]));
      break;
   case 6:
      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]));
      break;
   case 5:
      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]));
      break;
   case 4:
      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]));
      break;
   case 3:
      p = new 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;
      result7->type = 'u';
      result7->tagnum = G__get_linked_tagnum(&G__G__Geom1LN_TGeoSphere);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_205_4_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   TGeoSphere *p=NULL;
   switch(libp->paran) {
   case 2:
      p = new TGeoSphere((Double_t*)G__int(libp->para[0]),(Int_t)G__int(libp->para[1]));
      break;
   case 1:
      p = new TGeoSphere((Double_t*)G__int(libp->para[0]));
      break;
   }
      result7->obj.i = (long)p;
      result7->ref = (long)p;
      result7->type = 'u';
      result7->tagnum = G__get_linked_tagnum(&G__G__Geom1LN_TGeoSphere);
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__Geom1_205_6_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoSphere*)(G__getstructoffset()))->ComputeNormal((Double_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_205_7_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__letint(result7,103,(long)((const TGeoSphere*)(G__getstructoffset()))->Contains((Double_t*)G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_205_8_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__letint(result7,105,(long)((TGeoSphere*)(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_205_9_0(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()))->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 TGeoSphere*)(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 TGeoSphere*)(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 TGeoSphere*)(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_205_0_1(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()))->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 TGeoSphere*)(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 TGeoSphere*)(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 TGeoSphere*)(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_205_1_1(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_205_2_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   G__letint(result7,85,(long)((TGeoSphere*)(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_205_3_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   G__letint(result7,67,(long)((const TGeoSphere*)(G__getstructoffset()))->GetAxisName((Int_t)G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_205_4_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__letdouble(result7,100,(double)((const TGeoSphere*)(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_205_5_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((const TGeoSphere*)(G__getstructoffset()))->GetBoundingCylinder((Double_t*)G__int(libp->para[0]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_205_6_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      {
        const TBuffer3D& obj=((const TGeoSphere*)(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_205_7_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__letint(result7,105,(long)((const TGeoSphere*)(G__getstructoffset()))->GetByteCount());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_205_8_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   G__letint(result7,85,(long)((const TGeoSphere*)(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_205_9_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__letint(result7,105,(long)((const TGeoSphere*)(G__getstructoffset()))->GetNmeshVertices());
   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) {
      G__letint(result7,105,(long)((const TGeoSphere*)(G__getstructoffset()))->GetNumberOfDivisions());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_205_1_2(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_205_2_2(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_205_3_2(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_205_4_2(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_205_5_2(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_205_6_2(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_205_7_2(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_205_8_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((const TGeoSphere*)(G__getstructoffset()))->InspectShape();
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_205_9_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__letint(result7,103,(long)((const TGeoSphere*)(G__getstructoffset()))->IsCylType());
   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) {
   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_205_1_3(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   G__letint(result7,85,(long)((const TGeoSphere*)(G__getstructoffset()))->MakeBuffer3D());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_205_2_3(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   switch(libp->paran) {
   case 2:
      G__letdouble(result7,100,(double)((const TGeoSphere*)(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 TGeoSphere*)(G__getstructoffset()))->Safety((Double_t*)G__int(libp->para[0])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_205_3_3(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoSphere*)(G__getstructoffset()))->SavePrimitive(*(ofstream*)libp->para[0].ref,(Option_t*)G__int(libp->para[1]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_205_4_3(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((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]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_205_5_3(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoSphere*)(G__getstructoffset()))->SetNumberOfDivisions((Int_t)G__int(libp->para[0]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_205_6_3(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoSphere*)(G__getstructoffset()))->SetDimensions((Double_t*)G__int(libp->para[0]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_205_7_3(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((const TGeoSphere*)(G__getstructoffset()))->SetPoints((Double_t*)G__int(libp->para[0]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_205_8_3(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((const TGeoSphere*)(G__getstructoffset()))->SetPoints((Float_t*)G__int(libp->para[0]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_205_9_3(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((const TGeoSphere*)(G__getstructoffset()))->SetSegsAndPols(*(TBuffer3D*)libp->para[0].ref);
   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) {
      G__setnull(result7);
      ((const TGeoSphere*)(G__getstructoffset()))->Sizeof3D();
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_205_1_4(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_205_2_4(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_205_3_4(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_205_4_4(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      TGeoSphere::Dictionary();
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__Geom1_205_6_4(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoSphere*)(G__getstructoffset()))->ShowMembers(*(TMemberInspector*)libp->para[0].ref,(char*)G__int(libp->para[1]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_205_7_4(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoSphere*)(G__getstructoffset()))->Streamer(*(TBuffer*)libp->para[0].ref);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_205_8_4(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoSphere*)(G__getstructoffset()))->StreamerNVirtual(*(TBuffer*)libp->para[0].ref);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_205_9_4(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_205_0_5(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_205_1_5(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_205_2_5(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_205_3_5(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash)
{
   TGeoSphere *p;
   void *xtmp = (void*)G__int(libp->para[0]);
   p=new TGeoSphere(*(TGeoSphere*)xtmp);
   result7->obj.i = (long)p;
   result7->ref = (long)p;
   result7->type = 'u';
   result7->tagnum = 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_205_4_5(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   if(0==G__getstructoffset()) return(1);
   if(G__getaryconstruct())
     if(G__PVOID==G__getgvp())
       delete[] (TGeoSphere *)(G__getstructoffset());
     else
       for(int i=G__getaryconstruct()-1;i>=0;i--)
         delete (TGeoSphere *)((G__getstructoffset())+sizeof(TGeoSphere)*i);
   else  delete (TGeoSphere *)(G__getstructoffset());
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__G__Geom1_205_5_5(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_206_1_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   TGeoEltu *p=NULL;
   if(G__getaryconstruct()) p=new TGeoEltu[G__getaryconstruct()];
   else                    p=new TGeoEltu;
      result7->obj.i = (long)p;
      result7->ref = (long)p;
      result7->type = 'u';
      result7->tagnum = G__get_linked_tagnum(&G__G__Geom1LN_TGeoEltu);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_206_2_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   TGeoEltu *p=NULL;
      p = new 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;
      result7->type = 'u';
      result7->tagnum = G__get_linked_tagnum(&G__G__Geom1LN_TGeoEltu);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_206_3_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   TGeoEltu *p=NULL;
      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]));
      result7->obj.i = (long)p;
      result7->ref = (long)p;
      result7->type = 'u';
      result7->tagnum = G__get_linked_tagnum(&G__G__Geom1LN_TGeoEltu);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_206_4_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   TGeoEltu *p=NULL;
      p = new TGeoEltu((Double_t*)G__int(libp->para[0]));
      result7->obj.i = (long)p;
      result7->ref = (long)p;
      result7->type = 'u';
      result7->tagnum = G__get_linked_tagnum(&G__G__Geom1LN_TGeoEltu);
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__Geom1_206_6_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoEltu*)(G__getstructoffset()))->ComputeNormal((Double_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_206_7_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__letint(result7,103,(long)((const TGeoEltu*)(G__getstructoffset()))->Contains((Double_t*)G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_206_8_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__letint(result7,105,(long)((TGeoEltu*)(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_206_9_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   switch(libp->paran) {
   case 5:
      G__letdouble(result7,100,(double)((const TGeoEltu*)(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 TGeoEltu*)(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 TGeoEltu*)(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 TGeoEltu*)(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_206_0_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   switch(libp->paran) {
   case 5:
      G__letdouble(result7,100,(double)((const TGeoEltu*)(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 TGeoEltu*)(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 TGeoEltu*)(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 TGeoEltu*)(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_206_1_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   G__letint(result7,85,(long)((TGeoEltu*)(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_206_2_1(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_206_3_1(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_206_4_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((const TGeoEltu*)(G__getstructoffset()))->GetBoundingCylinder((Double_t*)G__int(libp->para[0]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_206_5_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      {
        const TBuffer3D& obj=((const TGeoEltu*)(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_206_6_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   G__letint(result7,85,(long)((const TGeoEltu*)(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_206_7_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__letint(result7,105,(long)((const TGeoEltu*)(G__getstructoffset()))->GetNmeshVertices());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_206_8_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((const TGeoEltu*)(G__getstructoffset()))->InspectShape();
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_206_9_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__letint(result7,103,(long)((const TGeoEltu*)(G__getstructoffset()))->IsCylType());
   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) {
   switch(libp->paran) {
   case 2:
      G__letdouble(result7,100,(double)((const TGeoEltu*)(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 TGeoEltu*)(G__getstructoffset()))->Safety((Double_t*)G__int(libp->para[0])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_206_1_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoEltu*)(G__getstructoffset()))->SavePrimitive(*(ofstream*)libp->para[0].ref,(Option_t*)G__int(libp->para[1]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_206_2_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((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]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_206_3_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoEltu*)(G__getstructoffset()))->SetDimensions((Double_t*)G__int(libp->para[0]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_206_4_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((const TGeoEltu*)(G__getstructoffset()))->SetPoints((Double_t*)G__int(libp->para[0]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_206_5_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((const TGeoEltu*)(G__getstructoffset()))->SetPoints((Float_t*)G__int(libp->para[0]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_206_6_2(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_206_7_2(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_206_8_2(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_206_9_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      TGeoEltu::Dictionary();
   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) {
   G__letint(result7,85,(long)((const TGeoEltu*)(G__getstructoffset()))->IsA());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_206_1_3(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoEltu*)(G__getstructoffset()))->ShowMembers(*(TMemberInspector*)libp->para[0].ref,(char*)G__int(libp->para[1]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_206_2_3(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoEltu*)(G__getstructoffset()))->Streamer(*(TBuffer*)libp->para[0].ref);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_206_3_3(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoEltu*)(G__getstructoffset()))->StreamerNVirtual(*(TBuffer*)libp->para[0].ref);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_206_4_3(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_206_5_3(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_206_6_3(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_206_7_3(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_206_8_3(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash)
{
   TGeoEltu *p;
   void *xtmp = (void*)G__int(libp->para[0]);
   p=new TGeoEltu(*(TGeoEltu*)xtmp);
   result7->obj.i = (long)p;
   result7->ref = (long)p;
   result7->type = 'u';
   result7->tagnum = 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_206_9_3(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   if(0==G__getstructoffset()) return(1);
   if(G__getaryconstruct())
     if(G__PVOID==G__getgvp())
       delete[] (TGeoEltu *)(G__getstructoffset());
     else
       for(int i=G__getaryconstruct()-1;i>=0;i--)
         delete (TGeoEltu *)((G__getstructoffset())+sizeof(TGeoEltu)*i);
   else  delete (TGeoEltu *)(G__getstructoffset());
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__G__Geom1_206_0_4(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_207_1_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   TGeoHype *p=NULL;
   if(G__getaryconstruct()) p=new TGeoHype[G__getaryconstruct()];
   else                    p=new TGeoHype;
      result7->obj.i = (long)p;
      result7->ref = (long)p;
      result7->type = 'u';
      result7->tagnum = G__get_linked_tagnum(&G__G__Geom1LN_TGeoHype);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_207_2_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   TGeoHype *p=NULL;
      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]));
      result7->obj.i = (long)p;
      result7->ref = (long)p;
      result7->type = 'u';
      result7->tagnum = G__get_linked_tagnum(&G__G__Geom1LN_TGeoHype);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_207_3_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   TGeoHype *p=NULL;
      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]));
      result7->obj.i = (long)p;
      result7->ref = (long)p;
      result7->type = 'u';
      result7->tagnum = G__get_linked_tagnum(&G__G__Geom1LN_TGeoHype);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_207_4_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   TGeoHype *p=NULL;
      p = new TGeoHype((Double_t*)G__int(libp->para[0]));
      result7->obj.i = (long)p;
      result7->ref = (long)p;
      result7->type = 'u';
      result7->tagnum = G__get_linked_tagnum(&G__G__Geom1LN_TGeoHype);
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__Geom1_207_6_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoHype*)(G__getstructoffset()))->ComputeNormal((Double_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_207_7_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__letint(result7,103,(long)((const TGeoHype*)(G__getstructoffset()))->Contains((Double_t*)G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_207_8_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   switch(libp->paran) {
   case 5:
      G__letdouble(result7,100,(double)((const TGeoHype*)(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 TGeoHype*)(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 TGeoHype*)(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 TGeoHype*)(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_207_9_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   switch(libp->paran) {
   case 5:
      G__letdouble(result7,100,(double)((const TGeoHype*)(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 TGeoHype*)(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 TGeoHype*)(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 TGeoHype*)(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_207_0_1(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_207_1_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__letint(result7,105,(long)((TGeoHype*)(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_207_2_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   G__letint(result7,85,(long)((TGeoHype*)(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_207_3_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__letdouble(result7,100,(double)((const TGeoHype*)(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_207_4_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((const TGeoHype*)(G__getstructoffset()))->GetBoundingCylinder((Double_t*)G__int(libp->para[0]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_207_5_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      {
        const TBuffer3D& obj=((const TGeoHype*)(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_207_6_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__letint(result7,105,(long)((const TGeoHype*)(G__getstructoffset()))->GetByteCount());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_207_7_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   G__letint(result7,85,(long)((const TGeoHype*)(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_207_8_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__letint(result7,105,(long)((const TGeoHype*)(G__getstructoffset()))->GetNmeshVertices());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_207_9_1(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_207_0_2(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_207_1_2(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_207_2_2(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_207_3_2(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_207_4_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((const TGeoHype*)(G__getstructoffset()))->InspectShape();
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_207_5_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__letint(result7,103,(long)((const TGeoHype*)(G__getstructoffset()))->IsCylType());
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__Geom1_207_7_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   switch(libp->paran) {
   case 2:
      G__letdouble(result7,100,(double)((const TGeoHype*)(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 TGeoHype*)(G__getstructoffset()))->Safety((Double_t*)G__int(libp->para[0])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_207_8_2(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_207_9_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoHype*)(G__getstructoffset()))->SavePrimitive(*(ofstream*)libp->para[0].ref,(Option_t*)G__int(libp->para[1]));
   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) {
      G__setnull(result7);
      ((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]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_207_1_3(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoHype*)(G__getstructoffset()))->SetDimensions((Double_t*)G__int(libp->para[0]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_207_2_3(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((const TGeoHype*)(G__getstructoffset()))->SetPoints((Double_t*)G__int(libp->para[0]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_207_3_3(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((const TGeoHype*)(G__getstructoffset()))->SetPoints((Float_t*)G__int(libp->para[0]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_207_4_3(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((const TGeoHype*)(G__getstructoffset()))->SetSegsAndPols(*(TBuffer3D*)libp->para[0].ref);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_207_5_3(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((const TGeoHype*)(G__getstructoffset()))->Sizeof3D();
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_207_6_3(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_207_7_3(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_207_8_3(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_207_9_3(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      TGeoHype::Dictionary();
   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) {
   G__letint(result7,85,(long)((const TGeoHype*)(G__getstructoffset()))->IsA());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_207_1_4(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoHype*)(G__getstructoffset()))->ShowMembers(*(TMemberInspector*)libp->para[0].ref,(char*)G__int(libp->para[1]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_207_2_4(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoHype*)(G__getstructoffset()))->Streamer(*(TBuffer*)libp->para[0].ref);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_207_3_4(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoHype*)(G__getstructoffset()))->StreamerNVirtual(*(TBuffer*)libp->para[0].ref);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_207_4_4(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_207_5_4(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_207_6_4(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_207_7_4(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_207_8_4(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash)
{
   TGeoHype *p;
   void *xtmp = (void*)G__int(libp->para[0]);
   p=new TGeoHype(*(TGeoHype*)xtmp);
   result7->obj.i = (long)p;
   result7->ref = (long)p;
   result7->type = 'u';
   result7->tagnum = 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_207_9_4(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   if(0==G__getstructoffset()) return(1);
   if(G__getaryconstruct())
     if(G__PVOID==G__getgvp())
       delete[] (TGeoHype *)(G__getstructoffset());
     else
       for(int i=G__getaryconstruct()-1;i>=0;i--)
         delete (TGeoHype *)((G__getstructoffset())+sizeof(TGeoHype)*i);
   else  delete (TGeoHype *)(G__getstructoffset());
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__G__Geom1_207_0_5(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_208_1_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   TGeoCone *p=NULL;
   if(G__getaryconstruct()) p=new TGeoCone[G__getaryconstruct()];
   else                    p=new TGeoCone;
      result7->obj.i = (long)p;
      result7->ref = (long)p;
      result7->type = 'u';
      result7->tagnum = G__get_linked_tagnum(&G__G__Geom1LN_TGeoCone);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_208_2_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   TGeoCone *p=NULL;
      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]));
      result7->obj.i = (long)p;
      result7->ref = (long)p;
      result7->type = 'u';
      result7->tagnum = G__get_linked_tagnum(&G__G__Geom1LN_TGeoCone);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_208_3_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   TGeoCone *p=NULL;
      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]));
      result7->obj.i = (long)p;
      result7->ref = (long)p;
      result7->type = 'u';
      result7->tagnum = G__get_linked_tagnum(&G__G__Geom1LN_TGeoCone);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_208_4_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   TGeoCone *p=NULL;
      p = new TGeoCone((Double_t*)G__int(libp->para[0]));
      result7->obj.i = (long)p;
      result7->ref = (long)p;
      result7->type = 'u';
      result7->tagnum = G__get_linked_tagnum(&G__G__Geom1LN_TGeoCone);
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__Geom1_208_6_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoCone*)(G__getstructoffset()))->ComputeNormal((Double_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_208_7_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      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]));
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__Geom1_208_9_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__letint(result7,105,(long)((TGeoCone*)(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_208_0_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      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]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_208_1_1(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_208_2_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   switch(libp->paran) {
   case 5:
      G__letdouble(result7,100,(double)((const TGeoCone*)(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 TGeoCone*)(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 TGeoCone*)(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 TGeoCone*)(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_208_3_1(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_208_4_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   switch(libp->paran) {
   case 5:
      G__letdouble(result7,100,(double)((const TGeoCone*)(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 TGeoCone*)(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 TGeoCone*)(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 TGeoCone*)(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_208_5_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   G__letint(result7,85,(long)((TGeoCone*)(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_208_6_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   G__letint(result7,67,(long)((const TGeoCone*)(G__getstructoffset()))->GetAxisName((Int_t)G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_208_7_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__letdouble(result7,100,(double)((const TGeoCone*)(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_208_8_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((const TGeoCone*)(G__getstructoffset()))->GetBoundingCylinder((Double_t*)G__int(libp->para[0]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_208_9_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__letint(result7,105,(long)((const TGeoCone*)(G__getstructoffset()))->GetByteCount());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_208_0_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      {
        const TBuffer3D& obj=((const TGeoCone*)(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_208_1_2(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_208_2_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   G__letint(result7,85,(long)((const TGeoCone*)(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_208_3_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__letint(result7,105,(long)((const TGeoCone*)(G__getstructoffset()))->GetNmeshVertices());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_208_4_2(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_208_5_2(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_208_6_2(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_208_7_2(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_208_8_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((const TGeoCone*)(G__getstructoffset()))->InspectShape();
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_208_9_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__letint(result7,103,(long)((const TGeoCone*)(G__getstructoffset()))->IsCylType());
   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__letint(result7,85,(long)((const TGeoCone*)(G__getstructoffset()))->MakeBuffer3D());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_208_1_3(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   switch(libp->paran) {
   case 2:
      G__letdouble(result7,100,(double)((const TGeoCone*)(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 TGeoCone*)(G__getstructoffset()))->Safety((Double_t*)G__int(libp->para[0])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_208_2_3(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_208_3_3(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoCone*)(G__getstructoffset()))->SavePrimitive(*(ofstream*)libp->para[0].ref,(Option_t*)G__int(libp->para[1]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_208_4_3(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((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]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_208_5_3(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoCone*)(G__getstructoffset()))->SetDimensions((Double_t*)G__int(libp->para[0]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_208_6_3(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((const TGeoCone*)(G__getstructoffset()))->SetPoints((Double_t*)G__int(libp->para[0]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_208_7_3(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((const TGeoCone*)(G__getstructoffset()))->SetPoints((Float_t*)G__int(libp->para[0]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_208_8_3(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((const TGeoCone*)(G__getstructoffset()))->SetSegsAndPols(*(TBuffer3D*)libp->para[0].ref);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_208_9_3(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((const TGeoCone*)(G__getstructoffset()))->Sizeof3D();
   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__letint(result7,85,(long)TGeoCone::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_208_1_4(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_208_2_4(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_208_3_4(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      TGeoCone::Dictionary();
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__Geom1_208_5_4(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoCone*)(G__getstructoffset()))->ShowMembers(*(TMemberInspector*)libp->para[0].ref,(char*)G__int(libp->para[1]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_208_6_4(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoCone*)(G__getstructoffset()))->Streamer(*(TBuffer*)libp->para[0].ref);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_208_7_4(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoCone*)(G__getstructoffset()))->StreamerNVirtual(*(TBuffer*)libp->para[0].ref);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_208_8_4(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_208_9_4(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_208_0_5(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_208_1_5(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_208_2_5(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash)
{
   TGeoCone *p;
   void *xtmp = (void*)G__int(libp->para[0]);
   p=new TGeoCone(*(TGeoCone*)xtmp);
   result7->obj.i = (long)p;
   result7->ref = (long)p;
   result7->type = 'u';
   result7->tagnum = 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_208_3_5(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   if(0==G__getstructoffset()) return(1);
   if(G__getaryconstruct())
     if(G__PVOID==G__getgvp())
       delete[] (TGeoCone *)(G__getstructoffset());
     else
       for(int i=G__getaryconstruct()-1;i>=0;i--)
         delete (TGeoCone *)((G__getstructoffset())+sizeof(TGeoCone)*i);
   else  delete (TGeoCone *)(G__getstructoffset());
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__G__Geom1_208_4_5(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_209_1_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   TGeoConeSeg *p=NULL;
   if(G__getaryconstruct()) p=new TGeoConeSeg[G__getaryconstruct()];
   else                    p=new TGeoConeSeg;
      result7->obj.i = (long)p;
      result7->ref = (long)p;
      result7->type = 'u';
      result7->tagnum = G__get_linked_tagnum(&G__G__Geom1LN_TGeoConeSeg);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_209_2_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   TGeoConeSeg *p=NULL;
      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]));
      result7->obj.i = (long)p;
      result7->ref = (long)p;
      result7->type = 'u';
      result7->tagnum = G__get_linked_tagnum(&G__G__Geom1LN_TGeoConeSeg);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_209_3_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   TGeoConeSeg *p=NULL;
      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]));
      result7->obj.i = (long)p;
      result7->ref = (long)p;
      result7->type = 'u';
      result7->tagnum = G__get_linked_tagnum(&G__G__Geom1LN_TGeoConeSeg);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_209_4_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   TGeoConeSeg *p=NULL;
      p = new TGeoConeSeg((Double_t*)G__int(libp->para[0]));
      result7->obj.i = (long)p;
      result7->ref = (long)p;
      result7->type = 'u';
      result7->tagnum = G__get_linked_tagnum(&G__G__Geom1LN_TGeoConeSeg);
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__Geom1_209_6_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoConeSeg*)(G__getstructoffset()))->ComputeNormal((Double_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_209_7_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      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]));
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__Geom1_209_9_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__letint(result7,105,(long)((TGeoConeSeg*)(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_209_0_1(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_209_1_1(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_209_2_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   switch(libp->paran) {
   case 5:
      G__letdouble(result7,100,(double)((const TGeoConeSeg*)(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 TGeoConeSeg*)(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 TGeoConeSeg*)(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 TGeoConeSeg*)(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_209_3_1(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_209_4_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   switch(libp->paran) {
   case 5:
      G__letdouble(result7,100,(double)((const TGeoConeSeg*)(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 TGeoConeSeg*)(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 TGeoConeSeg*)(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 TGeoConeSeg*)(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_209_5_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   G__letint(result7,85,(long)((TGeoConeSeg*)(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_209_6_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__letdouble(result7,100,(double)((const TGeoConeSeg*)(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_209_7_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((const TGeoConeSeg*)(G__getstructoffset()))->GetBoundingCylinder((Double_t*)G__int(libp->para[0]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_209_8_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      {
        const TBuffer3D& obj=((const TGeoConeSeg*)(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_209_9_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__letint(result7,105,(long)((const TGeoConeSeg*)(G__getstructoffset()))->GetByteCount());
   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) {
   G__letint(result7,85,(long)((const TGeoConeSeg*)(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_209_1_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__letint(result7,105,(long)((const TGeoConeSeg*)(G__getstructoffset()))->GetNmeshVertices());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_209_2_2(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_209_3_2(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_209_4_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((const TGeoConeSeg*)(G__getstructoffset()))->InspectShape();
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__Geom1_209_6_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   switch(libp->paran) {
   case 2:
      G__letdouble(result7,100,(double)((const TGeoConeSeg*)(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 TGeoConeSeg*)(G__getstructoffset()))->Safety((Double_t*)G__int(libp->para[0])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_209_7_2(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_209_8_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoConeSeg*)(G__getstructoffset()))->SavePrimitive(*(ofstream*)libp->para[0].ref,(Option_t*)G__int(libp->para[1]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_209_9_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((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]));
   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) {
      G__setnull(result7);
      ((TGeoConeSeg*)(G__getstructoffset()))->SetDimensions((Double_t*)G__int(libp->para[0]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_209_1_3(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((const TGeoConeSeg*)(G__getstructoffset()))->SetPoints((Double_t*)G__int(libp->para[0]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_209_2_3(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((const TGeoConeSeg*)(G__getstructoffset()))->SetPoints((Float_t*)G__int(libp->para[0]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_209_3_3(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((const TGeoConeSeg*)(G__getstructoffset()))->SetSegsAndPols(*(TBuffer3D*)libp->para[0].ref);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_209_4_3(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((const TGeoConeSeg*)(G__getstructoffset()))->Sizeof3D();
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_209_5_3(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_209_6_3(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_209_7_3(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_209_8_3(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      TGeoConeSeg::Dictionary();
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_209_9_3(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   G__letint(result7,85,(long)((const TGeoConeSeg*)(G__getstructoffset()))->IsA());
   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) {
      G__setnull(result7);
      ((TGeoConeSeg*)(G__getstructoffset()))->ShowMembers(*(TMemberInspector*)libp->para[0].ref,(char*)G__int(libp->para[1]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_209_1_4(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoConeSeg*)(G__getstructoffset()))->Streamer(*(TBuffer*)libp->para[0].ref);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_209_2_4(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoConeSeg*)(G__getstructoffset()))->StreamerNVirtual(*(TBuffer*)libp->para[0].ref);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_209_3_4(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_209_4_4(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_209_5_4(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_209_6_4(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_209_7_4(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash)
{
   TGeoConeSeg *p;
   void *xtmp = (void*)G__int(libp->para[0]);
   p=new TGeoConeSeg(*(TGeoConeSeg*)xtmp);
   result7->obj.i = (long)p;
   result7->ref = (long)p;
   result7->type = 'u';
   result7->tagnum = 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_209_8_4(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   if(0==G__getstructoffset()) return(1);
   if(G__getaryconstruct())
     if(G__PVOID==G__getgvp())
       delete[] (TGeoConeSeg *)(G__getstructoffset());
     else
       for(int i=G__getaryconstruct()-1;i>=0;i--)
         delete (TGeoConeSeg *)((G__getstructoffset())+sizeof(TGeoConeSeg)*i);
   else  delete (TGeoConeSeg *)(G__getstructoffset());
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__G__Geom1_209_9_4(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_210_1_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   TGeoPcon *p=NULL;
   if(G__getaryconstruct()) p=new TGeoPcon[G__getaryconstruct()];
   else                    p=new TGeoPcon;
      result7->obj.i = (long)p;
      result7->ref = (long)p;
      result7->type = 'u';
      result7->tagnum = G__get_linked_tagnum(&G__G__Geom1LN_TGeoPcon);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_210_2_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   TGeoPcon *p=NULL;
      p = new 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;
      result7->type = 'u';
      result7->tagnum = G__get_linked_tagnum(&G__G__Geom1LN_TGeoPcon);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_210_3_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   TGeoPcon *p=NULL;
      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]));
      result7->obj.i = (long)p;
      result7->ref = (long)p;
      result7->type = 'u';
      result7->tagnum = G__get_linked_tagnum(&G__G__Geom1LN_TGeoPcon);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_210_4_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   TGeoPcon *p=NULL;
      p = new TGeoPcon((Double_t*)G__int(libp->para[0]));
      result7->obj.i = (long)p;
      result7->ref = (long)p;
      result7->type = 'u';
      result7->tagnum = G__get_linked_tagnum(&G__G__Geom1LN_TGeoPcon);
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__Geom1_210_6_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoPcon*)(G__getstructoffset()))->ComputeNormal((Double_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_210_7_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__letint(result7,103,(long)((const TGeoPcon*)(G__getstructoffset()))->Contains((Double_t*)G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_210_8_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((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]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_210_9_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   switch(libp->paran) {
   case 5:
      G__letdouble(result7,100,(double)((const TGeoPcon*)(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 TGeoPcon*)(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 TGeoPcon*)(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 TGeoPcon*)(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_210_0_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   switch(libp->paran) {
   case 5:
      G__letdouble(result7,100,(double)((const TGeoPcon*)(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 TGeoPcon*)(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 TGeoPcon*)(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 TGeoPcon*)(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_210_1_1(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_210_2_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__letint(result7,105,(long)((TGeoPcon*)(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_210_3_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   G__letint(result7,85,(long)((TGeoPcon*)(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_210_4_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   G__letint(result7,67,(long)((const TGeoPcon*)(G__getstructoffset()))->GetAxisName((Int_t)G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_210_5_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__letdouble(result7,100,(double)((const TGeoPcon*)(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_210_6_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((const TGeoPcon*)(G__getstructoffset()))->GetBoundingCylinder((Double_t*)G__int(libp->para[0]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_210_7_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      {
        const TBuffer3D& obj=((const TGeoPcon*)(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_210_8_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__letint(result7,105,(long)((const TGeoPcon*)(G__getstructoffset()))->GetByteCount());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_210_9_1(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_210_0_2(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_210_1_2(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_210_2_2(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_210_3_2(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_210_4_2(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_210_5_2(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_210_6_2(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_210_7_2(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_210_8_2(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_210_9_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   G__letint(result7,85,(long)((const TGeoPcon*)(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_210_0_3(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__letint(result7,105,(long)((const TGeoPcon*)(G__getstructoffset()))->GetNmeshVertices());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_210_1_3(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((const TGeoPcon*)(G__getstructoffset()))->InspectShape();
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_210_2_3(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__letint(result7,103,(long)((const TGeoPcon*)(G__getstructoffset()))->IsCylType());
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__Geom1_210_4_3(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_210_5_3(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_210_6_3(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_210_7_3(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_210_8_3(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_210_9_3(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   switch(libp->paran) {
   case 2:
      G__letdouble(result7,100,(double)((const TGeoPcon*)(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 TGeoPcon*)(G__getstructoffset()))->Safety((Double_t*)G__int(libp->para[0])));
      break;
   }
   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) {
   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_210_1_4(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoPcon*)(G__getstructoffset()))->SavePrimitive(*(ofstream*)libp->para[0].ref,(Option_t*)G__int(libp->para[1]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_210_2_4(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoPcon*)(G__getstructoffset()))->SetDimensions((Double_t*)G__int(libp->para[0]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_210_3_4(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((const TGeoPcon*)(G__getstructoffset()))->SetPoints((Double_t*)G__int(libp->para[0]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_210_4_4(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((const TGeoPcon*)(G__getstructoffset()))->SetPoints((Float_t*)G__int(libp->para[0]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_210_5_4(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((const TGeoPcon*)(G__getstructoffset()))->SetSegsAndPols(*(TBuffer3D*)libp->para[0].ref);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_210_6_4(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((const TGeoPcon*)(G__getstructoffset()))->Sizeof3D();
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_210_7_4(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_210_8_4(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_210_9_4(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_210_0_5(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      TGeoPcon::Dictionary();
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__Geom1_210_2_5(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoPcon*)(G__getstructoffset()))->ShowMembers(*(TMemberInspector*)libp->para[0].ref,(char*)G__int(libp->para[1]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_210_3_5(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoPcon*)(G__getstructoffset()))->Streamer(*(TBuffer*)libp->para[0].ref);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_210_4_5(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoPcon*)(G__getstructoffset()))->StreamerNVirtual(*(TBuffer*)libp->para[0].ref);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_210_5_5(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_210_6_5(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_210_7_5(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_210_8_5(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 copy constructor
static int G__G__Geom1_210_9_5(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash)
{
   TGeoPcon *p;
   void *xtmp = (void*)G__int(libp->para[0]);
   p=new TGeoPcon(*(TGeoPcon*)xtmp);
   result7->obj.i = (long)p;
   result7->ref = (long)p;
   result7->type = 'u';
   result7->tagnum = G__get_linked_tagnum(&G__G__Geom1LN_TGeoPcon);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGeoPcon G__TTGeoPcon;
static int G__G__Geom1_210_0_6(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   if(0==G__getstructoffset()) return(1);
   if(G__getaryconstruct())
     if(G__PVOID==G__getgvp())
       delete[] (TGeoPcon *)(G__getstructoffset());
     else
       for(int i=G__getaryconstruct()-1;i>=0;i--)
         delete (TGeoPcon *)((G__getstructoffset())+sizeof(TGeoPcon)*i);
   else  delete (TGeoPcon *)(G__getstructoffset());
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__G__Geom1_210_1_6(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   TGeoPcon *dest = (TGeoPcon*)(G__getstructoffset());
   *dest = (*(TGeoPcon*)libp->para[0].ref);
   const TGeoPcon& obj = *dest;
   result7->ref=(long)(&obj); result7->obj.i=(long)(&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGeoPgon */
static int G__G__Geom1_211_0_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   TGeoPgon *p=NULL;
   if(G__getaryconstruct()) p=new TGeoPgon[G__getaryconstruct()];
   else                    p=new TGeoPgon;
      result7->obj.i = (long)p;
      result7->ref = (long)p;
      result7->type = 'u';
      result7->tagnum = G__get_linked_tagnum(&G__G__Geom1LN_TGeoPgon);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_211_1_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   TGeoPgon *p=NULL;
      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]));
      result7->obj.i = (long)p;
      result7->ref = (long)p;
      result7->type = 'u';
      result7->tagnum = G__get_linked_tagnum(&G__G__Geom1LN_TGeoPgon);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_211_2_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   TGeoPgon *p=NULL;
      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]));
      result7->obj.i = (long)p;
      result7->ref = (long)p;
      result7->type = 'u';
      result7->tagnum = G__get_linked_tagnum(&G__G__Geom1LN_TGeoPgon);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_211_3_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   TGeoPgon *p=NULL;
      p = new TGeoPgon((Double_t*)G__int(libp->para[0]));
      result7->obj.i = (long)p;
      result7->ref = (long)p;
      result7->type = 'u';
      result7->tagnum = G__get_linked_tagnum(&G__G__Geom1LN_TGeoPgon);
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__Geom1_211_5_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoPgon*)(G__getstructoffset()))->ComputeNormal((Double_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_211_6_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__letint(result7,103,(long)((const TGeoPgon*)(G__getstructoffset()))->Contains((Double_t*)G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_211_7_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoPgon*)(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]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_211_8_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   switch(libp->paran) {
   case 5:
      G__letdouble(result7,100,(double)((const TGeoPgon*)(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 TGeoPgon*)(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 TGeoPgon*)(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 TGeoPgon*)(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_211_9_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   switch(libp->paran) {
   case 5:
      G__letdouble(result7,100,(double)((const TGeoPgon*)(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 TGeoPgon*)(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 TGeoPgon*)(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 TGeoPgon*)(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_211_0_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__letint(result7,105,(long)((TGeoPgon*)(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_211_1_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   G__letint(result7,85,(long)((TGeoPgon*)(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_211_2_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((const TGeoPgon*)(G__getstructoffset()))->GetBoundingCylinder((Double_t*)G__int(libp->para[0]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_211_3_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      {
        const TBuffer3D& obj=((const TGeoPgon*)(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_211_4_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__letint(result7,105,(long)((const TGeoPgon*)(G__getstructoffset()))->GetByteCount());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_211_5_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   G__letint(result7,85,(long)((const TGeoPgon*)(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_211_6_2(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_211_7_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__letint(result7,105,(long)((const TGeoPgon*)(G__getstructoffset()))->GetNmeshVertices());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_211_8_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__letint(result7,105,(long)((const TGeoPgon*)(G__getstructoffset()))->GetNsegments());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_211_9_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((const TGeoPgon*)(G__getstructoffset()))->InspectShape();
   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) {
   G__letint(result7,85,(long)((const TGeoPgon*)(G__getstructoffset()))->MakeBuffer3D());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_211_1_3(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   switch(libp->paran) {
   case 2:
      G__letdouble(result7,100,(double)((const TGeoPgon*)(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 TGeoPgon*)(G__getstructoffset()))->Safety((Double_t*)G__int(libp->para[0])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_211_2_3(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_211_3_3(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoPgon*)(G__getstructoffset()))->SavePrimitive(*(ofstream*)libp->para[0].ref,(Option_t*)G__int(libp->para[1]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_211_4_3(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoPgon*)(G__getstructoffset()))->SetDimensions((Double_t*)G__int(libp->para[0]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_211_5_3(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((const TGeoPgon*)(G__getstructoffset()))->SetPoints((Double_t*)G__int(libp->para[0]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_211_6_3(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((const TGeoPgon*)(G__getstructoffset()))->SetPoints((Float_t*)G__int(libp->para[0]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_211_7_3(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((const TGeoPgon*)(G__getstructoffset()))->SetSegsAndPols(*(TBuffer3D*)libp->para[0].ref);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_211_8_3(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((const TGeoPgon*)(G__getstructoffset()))->Sizeof3D();
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_211_9_3(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_211_0_4(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_211_1_4(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_211_2_4(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      TGeoPgon::Dictionary();
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__Geom1_211_4_4(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoPgon*)(G__getstructoffset()))->ShowMembers(*(TMemberInspector*)libp->para[0].ref,(char*)G__int(libp->para[1]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_211_5_4(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoPgon*)(G__getstructoffset()))->Streamer(*(TBuffer*)libp->para[0].ref);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_211_6_4(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoPgon*)(G__getstructoffset()))->StreamerNVirtual(*(TBuffer*)libp->para[0].ref);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_211_7_4(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_211_8_4(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_211_9_4(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_211_0_5(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_211_1_5(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash)
{
   TGeoPgon *p;
   void *xtmp = (void*)G__int(libp->para[0]);
   p=new TGeoPgon(*(TGeoPgon*)xtmp);
   result7->obj.i = (long)p;
   result7->ref = (long)p;
   result7->type = 'u';
   result7->tagnum = 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_211_2_5(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   if(0==G__getstructoffset()) return(1);
   if(G__getaryconstruct())
     if(G__PVOID==G__getgvp())
       delete[] (TGeoPgon *)(G__getstructoffset());
     else
       for(int i=G__getaryconstruct()-1;i>=0;i--)
         delete (TGeoPgon *)((G__getstructoffset())+sizeof(TGeoPgon)*i);
   else  delete (TGeoPgon *)(G__getstructoffset());
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__G__Geom1_211_3_5(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   TGeoPgon *dest = (TGeoPgon*)(G__getstructoffset());
   *dest = (*(TGeoPgon*)libp->para[0].ref);
   const TGeoPgon& obj = *dest;
   result7->ref=(long)(&obj); result7->obj.i=(long)(&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGeoArb8 */
static int G__G__Geom1_212_1_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   TGeoArb8 *p=NULL;
   if(G__getaryconstruct()) p=new TGeoArb8[G__getaryconstruct()];
   else                    p=new TGeoArb8;
      result7->obj.i = (long)p;
      result7->ref = (long)p;
      result7->type = 'u';
      result7->tagnum = G__get_linked_tagnum(&G__G__Geom1LN_TGeoArb8);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_212_2_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   TGeoArb8 *p=NULL;
   switch(libp->paran) {
   case 2:
      p = new TGeoArb8((Double_t)G__double(libp->para[0]),(Double_t*)G__int(libp->para[1]));
      break;
   case 1:
      p = new TGeoArb8((Double_t)G__double(libp->para[0]));
      break;
   }
      result7->obj.i = (long)p;
      result7->ref = (long)p;
      result7->type = 'u';
      result7->tagnum = G__get_linked_tagnum(&G__G__Geom1LN_TGeoArb8);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_212_3_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   TGeoArb8 *p=NULL;
   switch(libp->paran) {
   case 3:
      p = new 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:
      p = new 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;
      result7->type = 'u';
      result7->tagnum = G__get_linked_tagnum(&G__G__Geom1LN_TGeoArb8);
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__Geom1_212_5_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoArb8*)(G__getstructoffset()))->ComputeNormal((Double_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_212_6_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoArb8*)(G__getstructoffset()))->ComputeTwist();
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__Geom1_212_8_0(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_212_9_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   switch(libp->paran) {
   case 5:
      G__letdouble(result7,100,(double)((const TGeoArb8*)(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 TGeoArb8*)(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 TGeoArb8*)(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 TGeoArb8*)(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_212_0_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   switch(libp->paran) {
   case 5:
      G__letdouble(result7,100,(double)((const TGeoArb8*)(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 TGeoArb8*)(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 TGeoArb8*)(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 TGeoArb8*)(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_212_1_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   G__letint(result7,85,(long)((TGeoArb8*)(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_212_2_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__letdouble(result7,100,(double)((const TGeoArb8*)(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_212_3_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((const TGeoArb8*)(G__getstructoffset()))->GetBoundingCylinder((Double_t*)G__int(libp->para[0]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_212_4_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__letint(result7,105,(long)((const TGeoArb8*)(G__getstructoffset()))->GetByteCount());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_212_5_1(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_212_6_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__letint(result7,105,(long)((const TGeoArb8*)(G__getstructoffset()))->GetFittingBox((const 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_212_7_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   G__letint(result7,85,(long)((const TGeoArb8*)(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_212_8_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      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]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_212_9_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__letint(result7,105,(long)((const TGeoArb8*)(G__getstructoffset()))->GetNmeshVertices());
   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) {
   G__letint(result7,68,(long)((TGeoArb8*)(G__getstructoffset()))->GetVertices());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_212_1_2(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_212_2_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__letint(result7,103,(long)((const TGeoArb8*)(G__getstructoffset()))->IsCylType());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_212_3_2(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_212_4_2(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_212_5_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((const TGeoArb8*)(G__getstructoffset()))->InspectShape();
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_212_6_2(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_212_7_2(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_212_8_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   switch(libp->paran) {
   case 2:
      G__letdouble(result7,100,(double)((const TGeoArb8*)(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 TGeoArb8*)(G__getstructoffset()))->Safety((Double_t*)G__int(libp->para[0])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_212_9_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoArb8*)(G__getstructoffset()))->SavePrimitive(*(ofstream*)libp->para[0].ref,(Option_t*)G__int(libp->para[1]));
   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) {
      G__setnull(result7);
      ((const TGeoArb8*)(G__getstructoffset()))->SetPlaneVertices((Double_t)G__double(libp->para[0]),(Double_t*)G__int(libp->para[1]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_212_1_3(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((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]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_212_2_3(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoArb8*)(G__getstructoffset()))->SetDimensions((Double_t*)G__int(libp->para[0]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_212_3_3(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((const TGeoArb8*)(G__getstructoffset()))->SetPoints((Double_t*)G__int(libp->para[0]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_212_4_3(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((const TGeoArb8*)(G__getstructoffset()))->SetPoints((Float_t*)G__int(libp->para[0]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_212_5_3(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((const TGeoArb8*)(G__getstructoffset()))->Sizeof3D();
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_212_6_3(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_212_7_3(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_212_8_3(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_212_9_3(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      TGeoArb8::Dictionary();
   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) {
   G__letint(result7,85,(long)((const TGeoArb8*)(G__getstructoffset()))->IsA());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_212_1_4(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoArb8*)(G__getstructoffset()))->ShowMembers(*(TMemberInspector*)libp->para[0].ref,(char*)G__int(libp->para[1]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_212_2_4(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoArb8*)(G__getstructoffset()))->Streamer(*(TBuffer*)libp->para[0].ref);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_212_3_4(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoArb8*)(G__getstructoffset()))->StreamerNVirtual(*(TBuffer*)libp->para[0].ref);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_212_4_4(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_212_5_4(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_212_6_4(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_212_7_4(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 copy constructor
static int G__G__Geom1_212_8_4(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash)
{
   TGeoArb8 *p;
   void *xtmp = (void*)G__int(libp->para[0]);
   p=new TGeoArb8(*(TGeoArb8*)xtmp);
   result7->obj.i = (long)p;
   result7->ref = (long)p;
   result7->type = 'u';
   result7->tagnum = G__get_linked_tagnum(&G__G__Geom1LN_TGeoArb8);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGeoArb8 G__TTGeoArb8;
static int G__G__Geom1_212_9_4(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   if(0==G__getstructoffset()) return(1);
   if(G__getaryconstruct())
     if(G__PVOID==G__getgvp())
       delete[] (TGeoArb8 *)(G__getstructoffset());
     else
       for(int i=G__getaryconstruct()-1;i>=0;i--)
         delete (TGeoArb8 *)((G__getstructoffset())+sizeof(TGeoArb8)*i);
   else  delete (TGeoArb8 *)(G__getstructoffset());
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__G__Geom1_212_0_5(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   TGeoArb8 *dest = (TGeoArb8*)(G__getstructoffset());
   *dest = (*(TGeoArb8*)libp->para[0].ref);
   const TGeoArb8& obj = *dest;
   result7->ref=(long)(&obj); result7->obj.i=(long)(&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGeoTrap */
static int G__G__Geom1_214_1_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   TGeoTrap *p=NULL;
   if(G__getaryconstruct()) p=new TGeoTrap[G__getaryconstruct()];
   else                    p=new TGeoTrap;
      result7->obj.i = (long)p;
      result7->ref = (long)p;
      result7->type = 'u';
      result7->tagnum = G__get_linked_tagnum(&G__G__Geom1LN_TGeoTrap);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_214_2_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   TGeoTrap *p=NULL;
      p = new 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;
      result7->type = 'u';
      result7->tagnum = G__get_linked_tagnum(&G__G__Geom1LN_TGeoTrap);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_214_3_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   TGeoTrap *p=NULL;
      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]));
      result7->obj.i = (long)p;
      result7->ref = (long)p;
      result7->type = 'u';
      result7->tagnum = G__get_linked_tagnum(&G__G__Geom1LN_TGeoTrap);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_214_4_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   TGeoTrap *p=NULL;
      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]));
      result7->obj.i = (long)p;
      result7->ref = (long)p;
      result7->type = 'u';
      result7->tagnum = G__get_linked_tagnum(&G__G__Geom1LN_TGeoTrap);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_214_5_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   switch(libp->paran) {
   case 5:
      G__letdouble(result7,100,(double)((const TGeoTrap*)(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 TGeoTrap*)(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 TGeoTrap*)(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 TGeoTrap*)(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_214_6_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   switch(libp->paran) {
   case 5:
      G__letdouble(result7,100,(double)((const TGeoTrap*)(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 TGeoTrap*)(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 TGeoTrap*)(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 TGeoTrap*)(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_214_7_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   G__letint(result7,85,(long)((TGeoTrap*)(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_214_8_0(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_214_9_0(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_214_0_1(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_214_1_1(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_214_2_1(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_214_3_1(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_214_4_1(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_214_5_1(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_214_6_1(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_214_7_1(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_214_8_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   G__letint(result7,85,(long)((const TGeoTrap*)(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_214_9_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__letint(result7,105,(long)((const TGeoTrap*)(G__getstructoffset()))->GetNmeshVertices());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_214_0_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   switch(libp->paran) {
   case 2:
      G__letdouble(result7,100,(double)((const TGeoTrap*)(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 TGeoTrap*)(G__getstructoffset()))->Safety((Double_t*)G__int(libp->para[0])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_214_1_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoTrap*)(G__getstructoffset()))->SavePrimitive(*(ofstream*)libp->para[0].ref,(Option_t*)G__int(libp->para[1]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_214_2_2(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_214_3_2(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_214_4_2(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_214_5_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      TGeoTrap::Dictionary();
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__Geom1_214_7_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoTrap*)(G__getstructoffset()))->ShowMembers(*(TMemberInspector*)libp->para[0].ref,(char*)G__int(libp->para[1]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_214_8_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoTrap*)(G__getstructoffset()))->Streamer(*(TBuffer*)libp->para[0].ref);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_214_9_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoTrap*)(G__getstructoffset()))->StreamerNVirtual(*(TBuffer*)libp->para[0].ref);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_214_0_3(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_214_1_3(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_214_2_3(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_214_3_3(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_214_4_3(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash)
{
   TGeoTrap *p;
   void *xtmp = (void*)G__int(libp->para[0]);
   p=new TGeoTrap(*(TGeoTrap*)xtmp);
   result7->obj.i = (long)p;
   result7->ref = (long)p;
   result7->type = 'u';
   result7->tagnum = 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_214_5_3(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   if(0==G__getstructoffset()) return(1);
   if(G__getaryconstruct())
     if(G__PVOID==G__getgvp())
       delete[] (TGeoTrap *)(G__getstructoffset());
     else
       for(int i=G__getaryconstruct()-1;i>=0;i--)
         delete (TGeoTrap *)((G__getstructoffset())+sizeof(TGeoTrap)*i);
   else  delete (TGeoTrap *)(G__getstructoffset());
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__G__Geom1_214_6_3(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   TGeoTrap *dest = (TGeoTrap*)(G__getstructoffset());
   *dest = (*(TGeoTrap*)libp->para[0].ref);
   const TGeoTrap& obj = *dest;
   result7->ref=(long)(&obj); result7->obj.i=(long)(&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGeoGtra */
static int G__G__Geom1_215_1_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   TGeoGtra *p=NULL;
   if(G__getaryconstruct()) p=new TGeoGtra[G__getaryconstruct()];
   else                    p=new TGeoGtra;
      result7->obj.i = (long)p;
      result7->ref = (long)p;
      result7->type = 'u';
      result7->tagnum = G__get_linked_tagnum(&G__G__Geom1LN_TGeoGtra);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_215_2_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   TGeoGtra *p=NULL;
      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]));
      result7->obj.i = (long)p;
      result7->ref = (long)p;
      result7->type = 'u';
      result7->tagnum = G__get_linked_tagnum(&G__G__Geom1LN_TGeoGtra);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_215_3_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   TGeoGtra *p=NULL;
      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]));
      result7->obj.i = (long)p;
      result7->ref = (long)p;
      result7->type = 'u';
      result7->tagnum = G__get_linked_tagnum(&G__G__Geom1LN_TGeoGtra);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_215_4_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   switch(libp->paran) {
   case 5:
      G__letdouble(result7,100,(double)((const TGeoGtra*)(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 TGeoGtra*)(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 TGeoGtra*)(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 TGeoGtra*)(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_215_5_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   switch(libp->paran) {
   case 5:
      G__letdouble(result7,100,(double)((const TGeoGtra*)(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 TGeoGtra*)(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 TGeoGtra*)(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 TGeoGtra*)(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_215_6_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   G__letint(result7,85,(long)((const TGeoGtra*)(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_215_7_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__letint(result7,105,(long)((const TGeoGtra*)(G__getstructoffset()))->GetNmeshVertices());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_215_8_0(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_215_9_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoGtra*)(G__getstructoffset()))->SavePrimitive(*(ofstream*)libp->para[0].ref,(Option_t*)G__int(libp->para[1]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_215_0_1(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_215_1_1(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_215_2_1(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_215_3_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      TGeoGtra::Dictionary();
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__Geom1_215_5_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoGtra*)(G__getstructoffset()))->ShowMembers(*(TMemberInspector*)libp->para[0].ref,(char*)G__int(libp->para[1]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_215_6_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoGtra*)(G__getstructoffset()))->Streamer(*(TBuffer*)libp->para[0].ref);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_215_7_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoGtra*)(G__getstructoffset()))->StreamerNVirtual(*(TBuffer*)libp->para[0].ref);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_215_8_1(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_215_9_1(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_215_0_2(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_215_1_2(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_215_2_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash)
{
   TGeoGtra *p;
   void *xtmp = (void*)G__int(libp->para[0]);
   p=new TGeoGtra(*(TGeoGtra*)xtmp);
   result7->obj.i = (long)p;
   result7->ref = (long)p;
   result7->type = 'u';
   result7->tagnum = 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_215_3_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   if(0==G__getstructoffset()) return(1);
   if(G__getaryconstruct())
     if(G__PVOID==G__getgvp())
       delete[] (TGeoGtra *)(G__getstructoffset());
     else
       for(int i=G__getaryconstruct()-1;i>=0;i--)
         delete (TGeoGtra *)((G__getstructoffset())+sizeof(TGeoGtra)*i);
   else  delete (TGeoGtra *)(G__getstructoffset());
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__G__Geom1_215_4_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   TGeoGtra *dest = (TGeoGtra*)(G__getstructoffset());
   *dest = (*(TGeoGtra*)libp->para[0].ref);
   const TGeoGtra& obj = *dest;
   result7->ref=(long)(&obj); result7->obj.i=(long)(&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGeoTrd1 */
static int G__G__Geom1_216_1_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   TGeoTrd1 *p=NULL;
   if(G__getaryconstruct()) p=new TGeoTrd1[G__getaryconstruct()];
   else                    p=new TGeoTrd1;
      result7->obj.i = (long)p;
      result7->ref = (long)p;
      result7->type = 'u';
      result7->tagnum = G__get_linked_tagnum(&G__G__Geom1LN_TGeoTrd1);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_216_2_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   TGeoTrd1 *p=NULL;
      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]));
      result7->obj.i = (long)p;
      result7->ref = (long)p;
      result7->type = 'u';
      result7->tagnum = G__get_linked_tagnum(&G__G__Geom1LN_TGeoTrd1);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_216_3_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   TGeoTrd1 *p=NULL;
      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]));
      result7->obj.i = (long)p;
      result7->ref = (long)p;
      result7->type = 'u';
      result7->tagnum = G__get_linked_tagnum(&G__G__Geom1LN_TGeoTrd1);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_216_4_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   TGeoTrd1 *p=NULL;
      p = new TGeoTrd1((Double_t*)G__int(libp->para[0]));
      result7->obj.i = (long)p;
      result7->ref = (long)p;
      result7->type = 'u';
      result7->tagnum = G__get_linked_tagnum(&G__G__Geom1LN_TGeoTrd1);
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__Geom1_216_6_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoTrd1*)(G__getstructoffset()))->ComputeNormal((Double_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_216_7_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__letint(result7,103,(long)((const TGeoTrd1*)(G__getstructoffset()))->Contains((Double_t*)G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_216_8_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   switch(libp->paran) {
   case 5:
      G__letdouble(result7,100,(double)((const TGeoTrd1*)(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 TGeoTrd1*)(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 TGeoTrd1*)(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 TGeoTrd1*)(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_216_9_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   switch(libp->paran) {
   case 5:
      G__letdouble(result7,100,(double)((const TGeoTrd1*)(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 TGeoTrd1*)(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 TGeoTrd1*)(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 TGeoTrd1*)(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_216_0_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   G__letint(result7,85,(long)((TGeoTrd1*)(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_216_1_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__letdouble(result7,100,(double)((const TGeoTrd1*)(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_216_2_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((const TGeoTrd1*)(G__getstructoffset()))->GetBoundingCylinder((Double_t*)G__int(libp->para[0]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_216_3_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__letint(result7,105,(long)((const TGeoTrd1*)(G__getstructoffset()))->GetByteCount());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_216_4_1(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_216_5_1(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_216_6_1(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_216_7_1(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_216_8_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__letint(result7,105,(long)((const TGeoTrd1*)(G__getstructoffset()))->GetFittingBox((const 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_216_9_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   G__letint(result7,85,(long)((const TGeoTrd1*)(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_216_0_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__letint(result7,105,(long)((const TGeoTrd1*)(G__getstructoffset()))->GetNmeshVertices());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_216_1_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((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]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_216_2_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((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]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_216_3_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((const TGeoTrd1*)(G__getstructoffset()))->InspectShape();
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_216_4_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__letint(result7,103,(long)((const TGeoTrd1*)(G__getstructoffset()))->IsCylType());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_216_5_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   switch(libp->paran) {
   case 2:
      G__letdouble(result7,100,(double)((const TGeoTrd1*)(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 TGeoTrd1*)(G__getstructoffset()))->Safety((Double_t*)G__int(libp->para[0])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_216_6_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoTrd1*)(G__getstructoffset()))->SavePrimitive(*(ofstream*)libp->para[0].ref,(Option_t*)G__int(libp->para[1]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_216_7_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoTrd1*)(G__getstructoffset()))->SetDimensions((Double_t*)G__int(libp->para[0]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_216_8_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((const TGeoTrd1*)(G__getstructoffset()))->SetPoints((Double_t*)G__int(libp->para[0]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_216_9_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((const TGeoTrd1*)(G__getstructoffset()))->SetPoints((Float_t*)G__int(libp->para[0]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_216_0_3(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((const TGeoTrd1*)(G__getstructoffset()))->SetVertex((Double_t*)G__int(libp->para[0]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_216_1_3(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((const TGeoTrd1*)(G__getstructoffset()))->Sizeof3D();
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_216_2_3(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_216_3_3(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_216_4_3(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_216_5_3(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      TGeoTrd1::Dictionary();
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__Geom1_216_7_3(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoTrd1*)(G__getstructoffset()))->ShowMembers(*(TMemberInspector*)libp->para[0].ref,(char*)G__int(libp->para[1]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_216_8_3(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoTrd1*)(G__getstructoffset()))->Streamer(*(TBuffer*)libp->para[0].ref);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_216_9_3(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoTrd1*)(G__getstructoffset()))->StreamerNVirtual(*(TBuffer*)libp->para[0].ref);
   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) {
   G__letint(result7,67,(long)TGeoTrd1::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_216_1_4(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_216_2_4(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_216_3_4(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_216_4_4(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash)
{
   TGeoTrd1 *p;
   void *xtmp = (void*)G__int(libp->para[0]);
   p=new TGeoTrd1(*(TGeoTrd1*)xtmp);
   result7->obj.i = (long)p;
   result7->ref = (long)p;
   result7->type = 'u';
   result7->tagnum = 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_216_5_4(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   if(0==G__getstructoffset()) return(1);
   if(G__getaryconstruct())
     if(G__PVOID==G__getgvp())
       delete[] (TGeoTrd1 *)(G__getstructoffset());
     else
       for(int i=G__getaryconstruct()-1;i>=0;i--)
         delete (TGeoTrd1 *)((G__getstructoffset())+sizeof(TGeoTrd1)*i);
   else  delete (TGeoTrd1 *)(G__getstructoffset());
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__G__Geom1_216_6_4(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_217_1_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   TGeoTrd2 *p=NULL;
   if(G__getaryconstruct()) p=new TGeoTrd2[G__getaryconstruct()];
   else                    p=new TGeoTrd2;
      result7->obj.i = (long)p;
      result7->ref = (long)p;
      result7->type = 'u';
      result7->tagnum = G__get_linked_tagnum(&G__G__Geom1LN_TGeoTrd2);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_217_2_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   TGeoTrd2 *p=NULL;
      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]));
      result7->obj.i = (long)p;
      result7->ref = (long)p;
      result7->type = 'u';
      result7->tagnum = G__get_linked_tagnum(&G__G__Geom1LN_TGeoTrd2);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_217_3_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   TGeoTrd2 *p=NULL;
      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]));
      result7->obj.i = (long)p;
      result7->ref = (long)p;
      result7->type = 'u';
      result7->tagnum = G__get_linked_tagnum(&G__G__Geom1LN_TGeoTrd2);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_217_4_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   TGeoTrd2 *p=NULL;
      p = new TGeoTrd2((Double_t*)G__int(libp->para[0]));
      result7->obj.i = (long)p;
      result7->ref = (long)p;
      result7->type = 'u';
      result7->tagnum = G__get_linked_tagnum(&G__G__Geom1LN_TGeoTrd2);
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

static int G__G__Geom1_217_7_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoTrd2*)(G__getstructoffset()))->ComputeNormal((Double_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_217_8_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   switch(libp->paran) {
   case 5:
      G__letdouble(result7,100,(double)((const TGeoTrd2*)(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 TGeoTrd2*)(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 TGeoTrd2*)(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 TGeoTrd2*)(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_217_9_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   switch(libp->paran) {
   case 5:
      G__letdouble(result7,100,(double)((const TGeoTrd2*)(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 TGeoTrd2*)(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 TGeoTrd2*)(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 TGeoTrd2*)(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_217_0_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   G__letint(result7,85,(long)((TGeoTrd2*)(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_217_1_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__letdouble(result7,100,(double)((const TGeoTrd2*)(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_217_2_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((const TGeoTrd2*)(G__getstructoffset()))->GetBoundingCylinder((Double_t*)G__int(libp->para[0]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_217_3_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__letint(result7,105,(long)((const TGeoTrd2*)(G__getstructoffset()))->GetByteCount());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_217_4_1(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_217_5_1(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_217_6_1(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_217_7_1(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_217_8_1(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_217_9_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__letint(result7,105,(long)((const TGeoTrd2*)(G__getstructoffset()))->GetFittingBox((const 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_217_0_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   G__letint(result7,85,(long)((const TGeoTrd2*)(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_217_1_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__letint(result7,105,(long)((const TGeoTrd2*)(G__getstructoffset()))->GetNmeshVertices());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_217_2_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((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]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_217_3_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((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]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_217_4_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((const TGeoTrd2*)(G__getstructoffset()))->InspectShape();
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_217_5_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__letint(result7,103,(long)((const TGeoTrd2*)(G__getstructoffset()))->IsCylType());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_217_6_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   switch(libp->paran) {
   case 2:
      G__letdouble(result7,100,(double)((const TGeoTrd2*)(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 TGeoTrd2*)(G__getstructoffset()))->Safety((Double_t*)G__int(libp->para[0])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_217_7_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoTrd2*)(G__getstructoffset()))->SavePrimitive(*(ofstream*)libp->para[0].ref,(Option_t*)G__int(libp->para[1]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_217_8_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoTrd2*)(G__getstructoffset()))->SetDimensions((Double_t*)G__int(libp->para[0]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_217_9_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((const TGeoTrd2*)(G__getstructoffset()))->SetPoints((Double_t*)G__int(libp->para[0]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_217_0_3(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((const TGeoTrd2*)(G__getstructoffset()))->SetPoints((Float_t*)G__int(libp->para[0]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_217_1_3(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((const TGeoTrd2*)(G__getstructoffset()))->SetVertex((Double_t*)G__int(libp->para[0]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_217_2_3(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((const TGeoTrd2*)(G__getstructoffset()))->Sizeof3D();
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_217_3_3(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_217_4_3(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_217_5_3(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_217_6_3(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      TGeoTrd2::Dictionary();
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__Geom1_217_8_3(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoTrd2*)(G__getstructoffset()))->ShowMembers(*(TMemberInspector*)libp->para[0].ref,(char*)G__int(libp->para[1]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_217_9_3(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoTrd2*)(G__getstructoffset()))->Streamer(*(TBuffer*)libp->para[0].ref);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_217_0_4(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoTrd2*)(G__getstructoffset()))->StreamerNVirtual(*(TBuffer*)libp->para[0].ref);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_217_1_4(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_217_2_4(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_217_3_4(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_217_4_4(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_217_5_4(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash)
{
   TGeoTrd2 *p;
   void *xtmp = (void*)G__int(libp->para[0]);
   p=new TGeoTrd2(*(TGeoTrd2*)xtmp);
   result7->obj.i = (long)p;
   result7->ref = (long)p;
   result7->type = 'u';
   result7->tagnum = 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_217_6_4(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   if(0==G__getstructoffset()) return(1);
   if(G__getaryconstruct())
     if(G__PVOID==G__getgvp())
       delete[] (TGeoTrd2 *)(G__getstructoffset());
     else
       for(int i=G__getaryconstruct()-1;i>=0;i--)
         delete (TGeoTrd2 *)((G__getstructoffset())+sizeof(TGeoTrd2)*i);
   else  delete (TGeoTrd2 *)(G__getstructoffset());
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__G__Geom1_217_7_4(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) ;
}


/* TVirtualGeoTrack */
static int G__G__Geom1_310_3_0(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_310_4_0(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_310_5_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((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]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_310_6_0(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_310_7_0(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_310_8_0(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_310_9_0(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_310_0_1(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_310_1_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   G__letint(result7,67,(long)((const TVirtualGeoTrack*)(G__getstructoffset()))->GetName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_310_2_1(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_310_3_1(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_310_4_1(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_310_5_1(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_310_6_1(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_310_7_1(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_310_8_1(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_310_9_1(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_310_0_2(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_310_1_2(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_310_2_2(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_310_3_2(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_310_4_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   switch(libp->paran) {
   case 1:
      G__setnull(result7);
      ((TVirtualGeoTrack*)(G__getstructoffset()))->Paint((Option_t*)G__int(libp->para[0]));
      break;
   case 0:
      G__setnull(result7);
      ((TVirtualGeoTrack*)(G__getstructoffset()))->Paint();
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_310_5_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TVirtualGeoTrack*)(G__getstructoffset()))->PaintCollect((Double_t)G__double(libp->para[0]),(Double_t*)G__int(libp->para[1]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_310_6_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TVirtualGeoTrack*)(G__getstructoffset()))->PaintCollectTrack((Double_t)G__double(libp->para[0]),(Double_t*)G__int(libp->para[1]));
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

static int G__G__Geom1_310_9_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TVirtualGeoTrack*)(G__getstructoffset()))->SetName((const char*)G__int(libp->para[0]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_310_0_3(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TVirtualGeoTrack*)(G__getstructoffset()))->SetParticle((TObject*)G__int(libp->para[0]));
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__Geom1_310_2_3(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TVirtualGeoTrack*)(G__getstructoffset()))->SetId((Int_t)G__int(libp->para[0]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_310_3_3(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TVirtualGeoTrack*)(G__getstructoffset()))->SetPDG((Int_t)G__int(libp->para[0]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_310_4_3(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_310_5_3(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_310_6_3(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_310_7_3(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      TVirtualGeoTrack::Dictionary();
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__Geom1_310_9_3(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TVirtualGeoTrack*)(G__getstructoffset()))->ShowMembers(*(TMemberInspector*)libp->para[0].ref,(char*)G__int(libp->para[1]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_310_0_4(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TVirtualGeoTrack*)(G__getstructoffset()))->Streamer(*(TBuffer*)libp->para[0].ref);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_310_1_4(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TVirtualGeoTrack*)(G__getstructoffset()))->StreamerNVirtual(*(TBuffer*)libp->para[0].ref);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_310_2_4(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_310_3_4(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_310_4_4(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_310_5_4(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_310_6_4(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   if(0==G__getstructoffset()) return(1);
   if(G__getaryconstruct())
     if(G__PVOID==G__getgvp())
       delete[] (TVirtualGeoTrack *)(G__getstructoffset());
     else
       for(int i=G__getaryconstruct()-1;i>=0;i--)
         delete (TVirtualGeoTrack *)((G__getstructoffset())+sizeof(TVirtualGeoTrack)*i);
   else  delete (TVirtualGeoTrack *)(G__getstructoffset());
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__G__Geom1_310_7_4(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   TVirtualGeoTrack *dest = (TVirtualGeoTrack*)(G__getstructoffset());
   *dest = (*(TVirtualGeoTrack*)libp->para[0].ref);
   const TVirtualGeoTrack& obj = *dest;
   result7->ref=(long)(&obj); result7->obj.i=(long)(&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGeoPhysicalNode */
static int G__G__Geom1_311_2_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   TGeoPhysicalNode *p=NULL;
   if(G__getaryconstruct()) p=new TGeoPhysicalNode[G__getaryconstruct()];
   else                    p=new TGeoPhysicalNode;
      result7->obj.i = (long)p;
      result7->ref = (long)p;
      result7->type = 'u';
      result7->tagnum = G__get_linked_tagnum(&G__G__Geom1LN_TGeoPhysicalNode);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_311_3_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   TGeoPhysicalNode *p=NULL;
      p = new TGeoPhysicalNode((const char*)G__int(libp->para[0]));
      result7->obj.i = (long)p;
      result7->ref = (long)p;
      result7->type = 'u';
      result7->tagnum = G__get_linked_tagnum(&G__G__Geom1LN_TGeoPhysicalNode);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_311_4_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   switch(libp->paran) {
   case 3:
      G__setnull(result7);
      ((TGeoPhysicalNode*)(G__getstructoffset()))->Align((TGeoMatrix*)G__int(libp->para[0]),(TGeoShape*)G__int(libp->para[1])
,(Bool_t)G__int(libp->para[2]));
      break;
   case 2:
      G__setnull(result7);
      ((TGeoPhysicalNode*)(G__getstructoffset()))->Align((TGeoMatrix*)G__int(libp->para[0]),(TGeoShape*)G__int(libp->para[1]));
      break;
   case 1:
      G__setnull(result7);
      ((TGeoPhysicalNode*)(G__getstructoffset()))->Align((TGeoMatrix*)G__int(libp->para[0]));
      break;
   case 0:
      G__setnull(result7);
      ((TGeoPhysicalNode*)(G__getstructoffset()))->Align();
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_311_5_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((const TGeoPhysicalNode*)(G__getstructoffset()))->cd();
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__Geom1_311_7_0(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_311_8_0(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_311_9_0(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_311_0_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   G__letint(result7,67,(long)((const TGeoPhysicalNode*)(G__getstructoffset()))->GetName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_311_1_1(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_311_2_1(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_311_3_1(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_311_4_1(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_311_5_1(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_311_6_1(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_311_7_1(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_311_8_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__letint(result7,103,(long)((TGeoPhysicalNode*)(G__getstructoffset()))->SetPath((const char*)G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

static int G__G__Geom1_311_4_2(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_311_5_2(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_311_6_2(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_311_7_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      TGeoPhysicalNode::Dictionary();
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__Geom1_311_9_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoPhysicalNode*)(G__getstructoffset()))->ShowMembers(*(TMemberInspector*)libp->para[0].ref,(char*)G__int(libp->para[1]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_311_0_3(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoPhysicalNode*)(G__getstructoffset()))->Streamer(*(TBuffer*)libp->para[0].ref);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_311_1_3(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoPhysicalNode*)(G__getstructoffset()))->StreamerNVirtual(*(TBuffer*)libp->para[0].ref);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_311_2_3(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_311_3_3(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_311_4_3(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_311_5_3(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 copy constructor
static int G__G__Geom1_311_6_3(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash)
{
   TGeoPhysicalNode *p;
   void *xtmp = (void*)G__int(libp->para[0]);
   p=new TGeoPhysicalNode(*(TGeoPhysicalNode*)xtmp);
   result7->obj.i = (long)p;
   result7->ref = (long)p;
   result7->type = 'u';
   result7->tagnum = G__get_linked_tagnum(&G__G__Geom1LN_TGeoPhysicalNode);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGeoPhysicalNode G__TTGeoPhysicalNode;
static int G__G__Geom1_311_7_3(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   if(0==G__getstructoffset()) return(1);
   if(G__getaryconstruct())
     if(G__PVOID==G__getgvp())
       delete[] (TGeoPhysicalNode *)(G__getstructoffset());
     else
       for(int i=G__getaryconstruct()-1;i>=0;i--)
         delete (TGeoPhysicalNode *)((G__getstructoffset())+sizeof(TGeoPhysicalNode)*i);
   else  delete (TGeoPhysicalNode *)(G__getstructoffset());
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__G__Geom1_311_8_3(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   TGeoPhysicalNode *dest = (TGeoPhysicalNode*)(G__getstructoffset());
   *dest = (*(TGeoPhysicalNode*)libp->para[0].ref);
   const TGeoPhysicalNode& obj = *dest;
   result7->ref=(long)(&obj); result7->obj.i=(long)(&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TVirtualGeoPainter */
static int G__G__Geom1_312_2_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((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]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_312_3_0(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_312_4_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   switch(libp->paran) {
   case 3:
      G__setnull(result7);
      ((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]));
      break;
   case 2:
      G__setnull(result7);
      ((TVirtualGeoPainter*)(G__getstructoffset()))->AddTrackPoint((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_312_5_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TVirtualGeoPainter*)(G__getstructoffset()))->BombTranslation((const 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_312_6_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   switch(libp->paran) {
   case 4:
      G__setnull(result7);
      ((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]));
      break;
   case 3:
      G__setnull(result7);
      ((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]));
      break;
   case 2:
      G__setnull(result7);
      ((TVirtualGeoPainter*)(G__getstructoffset()))->CheckPoint((Double_t)G__double(libp->para[0]),(Double_t)G__double(libp->para[1]));
      break;
   case 1:
      G__setnull(result7);
      ((TVirtualGeoPainter*)(G__getstructoffset()))->CheckPoint((Double_t)G__double(libp->para[0]));
      break;
   case 0:
      G__setnull(result7);
      ((TVirtualGeoPainter*)(G__getstructoffset()))->CheckPoint();
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_312_7_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((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]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_312_8_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   switch(libp->paran) {
   case 3:
      G__setnull(result7);
      ((const TVirtualGeoPainter*)(G__getstructoffset()))->CheckOverlaps((const TGeoVolume*)G__int(libp->para[0]),(Double_t)G__double(libp->para[1])
,(Option_t*)G__int(libp->para[2]));
      break;
   case 2:
      G__setnull(result7);
      ((const TVirtualGeoPainter*)(G__getstructoffset()))->CheckOverlaps((const TGeoVolume*)G__int(libp->para[0]),(Double_t)G__double(libp->para[1]));
      break;
   case 1:
      G__setnull(result7);
      ((const TVirtualGeoPainter*)(G__getstructoffset()))->CheckOverlaps((const TGeoVolume*)G__int(libp->para[0]));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_312_9_0(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_312_0_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TVirtualGeoPainter*)(G__getstructoffset()))->DefaultAngles();
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__Geom1_312_2_1(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_312_3_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   switch(libp->paran) {
   case 1:
      G__setnull(result7);
      ((TVirtualGeoPainter*)(G__getstructoffset()))->Draw((Option_t*)G__int(libp->para[0]));
      break;
   case 0:
      G__setnull(result7);
      ((TVirtualGeoPainter*)(G__getstructoffset()))->Draw();
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__Geom1_312_5_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   switch(libp->paran) {
   case 2:
      G__setnull(result7);
      ((TVirtualGeoPainter*)(G__getstructoffset()))->DrawOverlap((void*)G__int(libp->para[0]),(Option_t*)G__int(libp->para[1]));
      break;
   case 1:
      G__setnull(result7);
      ((TVirtualGeoPainter*)(G__getstructoffset()))->DrawOverlap((void*)G__int(libp->para[0]));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_312_6_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TVirtualGeoPainter*)(G__getstructoffset()))->DrawCurrentPoint((Int_t)G__int(libp->para[0]));
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__Geom1_312_8_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TVirtualGeoPainter*)(G__getstructoffset()))->DrawPath((const char*)G__int(libp->para[0]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_312_9_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((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]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_312_0_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((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]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_312_1_2(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_312_2_2(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_312_3_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((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]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_312_4_2(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_312_5_2(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_312_6_2(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_312_7_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((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]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_312_8_2(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_312_9_2(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_312_0_3(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   G__letint(result7,67,(long)((const TVirtualGeoPainter*)(G__getstructoffset()))->GetVolumeInfo((const 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_312_1_3(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   switch(libp->paran) {
   case 4:
      G__setnull(result7);
      ((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]));
      break;
   case 3:
      G__setnull(result7);
      ((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]));
      break;
   case 2:
      G__setnull(result7);
      ((TVirtualGeoPainter*)(G__getstructoffset()))->GrabFocus((Int_t)G__int(libp->para[0]),(Double_t)G__double(libp->para[1]));
      break;
   case 1:
      G__setnull(result7);
      ((TVirtualGeoPainter*)(G__getstructoffset()))->GrabFocus((Int_t)G__int(libp->para[0]));
      break;
   case 0:
      G__setnull(result7);
      ((TVirtualGeoPainter*)(G__getstructoffset()))->GrabFocus();
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_312_2_3(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_312_3_3(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_312_4_3(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_312_5_3(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_312_6_3(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((const TVirtualGeoPainter*)(G__getstructoffset()))->ModifiedPad();
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__Geom1_312_8_3(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   switch(libp->paran) {
   case 2:
      G__setnull(result7);
      ((TVirtualGeoPainter*)(G__getstructoffset()))->PaintNode((TGeoNode*)G__int(libp->para[0]),(Option_t*)G__int(libp->para[1]));
      break;
   case 1:
      G__setnull(result7);
      ((TVirtualGeoPainter*)(G__getstructoffset()))->PaintNode((TGeoNode*)G__int(libp->para[0]));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_312_9_3(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   switch(libp->paran) {
   case 2:
      G__setnull(result7);
      ((TVirtualGeoPainter*)(G__getstructoffset()))->PaintOverlap((void*)G__int(libp->para[0]),(Option_t*)G__int(libp->para[1]));
      break;
   case 1:
      G__setnull(result7);
      ((TVirtualGeoPainter*)(G__getstructoffset()))->PaintOverlap((void*)G__int(libp->para[0]));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_312_0_4(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((const TVirtualGeoPainter*)(G__getstructoffset()))->PrintOverlaps();
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_312_1_4(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   switch(libp->paran) {
   case 3:
      G__setnull(result7);
      ((TVirtualGeoPainter*)(G__getstructoffset()))->RandomPoints((const TGeoVolume*)G__int(libp->para[0]),(Int_t)G__int(libp->para[1])
,(Option_t*)G__int(libp->para[2]));
      break;
   case 2:
      G__setnull(result7);
      ((TVirtualGeoPainter*)(G__getstructoffset()))->RandomPoints((const TGeoVolume*)G__int(libp->para[0]),(Int_t)G__int(libp->para[1]));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_312_2_4(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((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]));
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__Geom1_312_4_4(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_312_5_4(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   switch(libp->paran) {
   case 4:
      G__setnull(result7);
      ((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]));
      break;
   case 3:
      G__setnull(result7);
      ((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]));
      break;
   case 2:
      G__setnull(result7);
      ((TVirtualGeoPainter*)(G__getstructoffset()))->SetBombFactors((Double_t)G__double(libp->para[0]),(Double_t)G__double(libp->para[1]));
      break;
   case 1:
      G__setnull(result7);
      ((TVirtualGeoPainter*)(G__getstructoffset()))->SetBombFactors((Double_t)G__double(libp->para[0]));
      break;
   case 0:
      G__setnull(result7);
      ((TVirtualGeoPainter*)(G__getstructoffset()))->SetBombFactors();
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_312_6_4(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TVirtualGeoPainter*)(G__getstructoffset()))->SetClippingShape((TGeoShape*)G__int(libp->para[0]));
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__Geom1_312_8_4(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TVirtualGeoPainter*)(G__getstructoffset()))->SetGeoManager((TGeoManager*)G__int(libp->para[0]));
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

static int G__G__Geom1_312_1_5(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_312_2_5(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      TVirtualGeoPainter::SetPainter((const TVirtualGeoPainter*)G__int(libp->para[0]));
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

static int G__G__Geom1_312_6_5(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__letint(result7,105,(long)((const TVirtualGeoPainter*)(G__getstructoffset()))->ShapeDistancetoPrimitive((const 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_312_7_5(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TVirtualGeoPainter*)(G__getstructoffset()))->Test((Int_t)G__int(libp->para[0]),(Option_t*)G__int(libp->para[1]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_312_8_5(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TVirtualGeoPainter*)(G__getstructoffset()))->TestOverlaps((const char*)G__int(libp->para[0]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_312_9_5(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_312_0_6(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TVirtualGeoPainter*)(G__getstructoffset()))->UnbombTranslation((const 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_312_1_6(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_312_2_6(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_312_3_6(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_312_4_6(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_312_5_6(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      TVirtualGeoPainter::Dictionary();
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__Geom1_312_7_6(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TVirtualGeoPainter*)(G__getstructoffset()))->ShowMembers(*(TMemberInspector*)libp->para[0].ref,(char*)G__int(libp->para[1]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_312_8_6(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TVirtualGeoPainter*)(G__getstructoffset()))->Streamer(*(TBuffer*)libp->para[0].ref);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_312_9_6(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TVirtualGeoPainter*)(G__getstructoffset()))->StreamerNVirtual(*(TBuffer*)libp->para[0].ref);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_312_0_7(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_312_1_7(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_312_2_7(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_312_3_7(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_312_4_7(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   if(0==G__getstructoffset()) return(1);
   if(G__getaryconstruct())
     if(G__PVOID==G__getgvp())
       delete[] (TVirtualGeoPainter *)(G__getstructoffset());
     else
       for(int i=G__getaryconstruct()-1;i>=0;i--)
         delete (TVirtualGeoPainter *)((G__getstructoffset())+sizeof(TVirtualGeoPainter)*i);
   else  delete (TVirtualGeoPainter *)(G__getstructoffset());
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__G__Geom1_312_5_7(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_313_1_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   TGeoCompositeShape *p=NULL;
   if(G__getaryconstruct()) p=new TGeoCompositeShape[G__getaryconstruct()];
   else                    p=new TGeoCompositeShape;
      result7->obj.i = (long)p;
      result7->ref = (long)p;
      result7->type = 'u';
      result7->tagnum = G__get_linked_tagnum(&G__G__Geom1LN_TGeoCompositeShape);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_313_2_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   TGeoCompositeShape *p=NULL;
      p = new TGeoCompositeShape((const char*)G__int(libp->para[0]),(const char*)G__int(libp->para[1]));
      result7->obj.i = (long)p;
      result7->ref = (long)p;
      result7->type = 'u';
      result7->tagnum = G__get_linked_tagnum(&G__G__Geom1LN_TGeoCompositeShape);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_313_3_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   TGeoCompositeShape *p=NULL;
      p = new TGeoCompositeShape((const char*)G__int(libp->para[0]));
      result7->obj.i = (long)p;
      result7->ref = (long)p;
      result7->type = 'u';
      result7->tagnum = G__get_linked_tagnum(&G__G__Geom1LN_TGeoCompositeShape);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_313_4_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   TGeoCompositeShape *p=NULL;
      p = new TGeoCompositeShape((const char*)G__int(libp->para[0]),(TGeoBoolNode*)G__int(libp->para[1]));
      result7->obj.i = (long)p;
      result7->ref = (long)p;
      result7->type = 'u';
      result7->tagnum = G__get_linked_tagnum(&G__G__Geom1LN_TGeoCompositeShape);
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__Geom1_313_6_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoCompositeShape*)(G__getstructoffset()))->ComputeNormal((Double_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_313_7_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__letint(result7,103,(long)((const TGeoCompositeShape*)(G__getstructoffset()))->Contains((Double_t*)G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_313_8_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   switch(libp->paran) {
   case 5:
      G__letdouble(result7,100,(double)((const TGeoCompositeShape*)(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 TGeoCompositeShape*)(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 TGeoCompositeShape*)(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 TGeoCompositeShape*)(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_313_9_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   switch(libp->paran) {
   case 5:
      G__letdouble(result7,100,(double)((const TGeoCompositeShape*)(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 TGeoCompositeShape*)(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 TGeoCompositeShape*)(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 TGeoCompositeShape*)(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_313_0_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   G__letint(result7,85,(long)((TGeoCompositeShape*)(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_313_1_1(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_313_2_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((const TGeoCompositeShape*)(G__getstructoffset()))->GetBoundingCylinder((Double_t*)G__int(libp->para[0]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_313_3_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   G__letint(result7,85,(long)((const TGeoCompositeShape*)(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_313_4_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__letint(result7,105,(long)((const TGeoCompositeShape*)(G__getstructoffset()))->GetNmeshVertices());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_313_5_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((const TGeoCompositeShape*)(G__getstructoffset()))->InspectShape();
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_313_6_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__letint(result7,103,(long)((const TGeoCompositeShape*)(G__getstructoffset()))->IsComposite());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_313_7_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__letint(result7,103,(long)((const TGeoCompositeShape*)(G__getstructoffset()))->IsCylType());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_313_8_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoCompositeShape*)(G__getstructoffset()))->MakeNode((const char*)G__int(libp->para[0]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_313_9_1(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_313_0_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   switch(libp->paran) {
   case 2:
      G__letdouble(result7,100,(double)((const TGeoCompositeShape*)(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 TGeoCompositeShape*)(G__getstructoffset()))->Safety((Double_t*)G__int(libp->para[0])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_313_1_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoCompositeShape*)(G__getstructoffset()))->SavePrimitive(*(ofstream*)libp->para[0].ref,(Option_t*)G__int(libp->para[1]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_313_2_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoCompositeShape*)(G__getstructoffset()))->SetDimensions((Double_t*)G__int(libp->para[0]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_313_3_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((const TGeoCompositeShape*)(G__getstructoffset()))->SetPoints((Double_t*)G__int(libp->para[0]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_313_4_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((const TGeoCompositeShape*)(G__getstructoffset()))->SetPoints((Float_t*)G__int(libp->para[0]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_313_5_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((const TGeoCompositeShape*)(G__getstructoffset()))->Sizeof3D();
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_313_6_2(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_313_7_2(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_313_8_2(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_313_9_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      TGeoCompositeShape::Dictionary();
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__Geom1_313_1_3(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoCompositeShape*)(G__getstructoffset()))->ShowMembers(*(TMemberInspector*)libp->para[0].ref,(char*)G__int(libp->para[1]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_313_2_3(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoCompositeShape*)(G__getstructoffset()))->Streamer(*(TBuffer*)libp->para[0].ref);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_313_3_3(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoCompositeShape*)(G__getstructoffset()))->StreamerNVirtual(*(TBuffer*)libp->para[0].ref);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_313_4_3(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_313_5_3(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_313_6_3(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_313_7_3(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 copy constructor
static int G__G__Geom1_313_8_3(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash)
{
   TGeoCompositeShape *p;
   void *xtmp = (void*)G__int(libp->para[0]);
   p=new TGeoCompositeShape(*(TGeoCompositeShape*)xtmp);
   result7->obj.i = (long)p;
   result7->ref = (long)p;
   result7->type = 'u';
   result7->tagnum = G__get_linked_tagnum(&G__G__Geom1LN_TGeoCompositeShape);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGeoCompositeShape G__TTGeoCompositeShape;
static int G__G__Geom1_313_9_3(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   if(0==G__getstructoffset()) return(1);
   if(G__getaryconstruct())
     if(G__PVOID==G__getgvp())
       delete[] (TGeoCompositeShape *)(G__getstructoffset());
     else
       for(int i=G__getaryconstruct()-1;i>=0;i--)
         delete (TGeoCompositeShape *)((G__getstructoffset())+sizeof(TGeoCompositeShape)*i);
   else  delete (TGeoCompositeShape *)(G__getstructoffset());
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__G__Geom1_313_0_4(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   TGeoCompositeShape *dest = (TGeoCompositeShape*)(G__getstructoffset());
   *dest = (*(TGeoCompositeShape*)libp->para[0].ref);
   const TGeoCompositeShape& obj = *dest;
   result7->ref=(long)(&obj); result7->obj.i=(long)(&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGeoPolygon */
static int G__G__Geom1_319_5_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   TGeoPolygon *p=NULL;
   if(G__getaryconstruct()) p=new TGeoPolygon[G__getaryconstruct()];
   else                    p=new TGeoPolygon;
      result7->obj.i = (long)p;
      result7->ref = (long)p;
      result7->type = 'u';
      result7->tagnum = G__get_linked_tagnum(&G__G__Geom1LN_TGeoPolygon);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_319_6_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   TGeoPolygon *p=NULL;
      p = new TGeoPolygon((Int_t)G__int(libp->para[0]));
      result7->obj.i = (long)p;
      result7->ref = (long)p;
      result7->type = 'u';
      result7->tagnum = G__get_linked_tagnum(&G__G__Geom1LN_TGeoPolygon);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_319_7_0(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_319_8_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoPolygon*)(G__getstructoffset()))->FinishPolygon();
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_319_9_0(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_319_0_1(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_319_1_1(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_319_2_1(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_319_3_1(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_319_4_1(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_319_5_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   switch(libp->paran) {
   case 1:
      G__setnull(result7);
      ((TGeoPolygon*)(G__getstructoffset()))->SetConvex((Bool_t)G__int(libp->para[0]));
      break;
   case 0:
      G__setnull(result7);
      ((TGeoPolygon*)(G__getstructoffset()))->SetConvex();
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_319_6_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoPolygon*)(G__getstructoffset()))->SetXY((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_319_7_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   switch(libp->paran) {
   case 1:
      G__setnull(result7);
      ((TGeoPolygon*)(G__getstructoffset()))->SetNextIndex((Int_t)G__int(libp->para[0]));
      break;
   case 0:
      G__setnull(result7);
      ((TGeoPolygon*)(G__getstructoffset()))->SetNextIndex();
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_319_8_1(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_319_9_1(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_319_0_2(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_319_1_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      TGeoPolygon::Dictionary();
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__Geom1_319_3_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoPolygon*)(G__getstructoffset()))->ShowMembers(*(TMemberInspector*)libp->para[0].ref,(char*)G__int(libp->para[1]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_319_4_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoPolygon*)(G__getstructoffset()))->Streamer(*(TBuffer*)libp->para[0].ref);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_319_5_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoPolygon*)(G__getstructoffset()))->StreamerNVirtual(*(TBuffer*)libp->para[0].ref);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_319_6_2(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_319_7_2(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_319_8_2(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_319_9_2(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_319_0_3(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash)
{
   TGeoPolygon *p;
   void *xtmp = (void*)G__int(libp->para[0]);
   p=new TGeoPolygon(*(TGeoPolygon*)xtmp);
   result7->obj.i = (long)p;
   result7->ref = (long)p;
   result7->type = 'u';
   result7->tagnum = 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_319_1_3(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   if(0==G__getstructoffset()) return(1);
   if(G__getaryconstruct())
     if(G__PVOID==G__getgvp())
       delete[] (TGeoPolygon *)(G__getstructoffset());
     else
       for(int i=G__getaryconstruct()-1;i>=0;i--)
         delete (TGeoPolygon *)((G__getstructoffset())+sizeof(TGeoPolygon)*i);
   else  delete (TGeoPolygon *)(G__getstructoffset());
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__G__Geom1_319_2_3(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_321_8_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   TGeoXtru *p=NULL;
   if(G__getaryconstruct()) p=new TGeoXtru[G__getaryconstruct()];
   else                    p=new TGeoXtru;
      result7->obj.i = (long)p;
      result7->ref = (long)p;
      result7->type = 'u';
      result7->tagnum = G__get_linked_tagnum(&G__G__Geom1LN_TGeoXtru);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_321_9_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   TGeoXtru *p=NULL;
      p = new TGeoXtru((Int_t)G__int(libp->para[0]));
      result7->obj.i = (long)p;
      result7->ref = (long)p;
      result7->type = 'u';
      result7->tagnum = G__get_linked_tagnum(&G__G__Geom1LN_TGeoXtru);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_321_0_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   TGeoXtru *p=NULL;
      p = new TGeoXtru((Double_t*)G__int(libp->para[0]));
      result7->obj.i = (long)p;
      result7->ref = (long)p;
      result7->type = 'u';
      result7->tagnum = G__get_linked_tagnum(&G__G__Geom1LN_TGeoXtru);
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__Geom1_321_2_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoXtru*)(G__getstructoffset()))->ComputeNormal((Double_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_321_3_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__letint(result7,103,(long)((const TGeoXtru*)(G__getstructoffset()))->Contains((Double_t*)G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_321_4_1(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]),(const Double_t*)G__int(libp->para[1])
,(const Double_t*)G__int(libp->para[2])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_321_5_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   switch(libp->paran) {
   case 5:
      G__setnull(result7);
      ((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]));
      break;
   case 4:
      G__setnull(result7);
      ((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]));
      break;
   case 3:
      G__setnull(result7);
      ((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]));
      break;
   case 2:
      G__setnull(result7);
      ((TGeoXtru*)(G__getstructoffset()))->DefineSection((Int_t)G__int(libp->para[0]),(Double_t)G__double(libp->para[1]));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_321_6_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   switch(libp->paran) {
   case 5:
      G__letdouble(result7,100,(double)((const TGeoXtru*)(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 TGeoXtru*)(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 TGeoXtru*)(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 TGeoXtru*)(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_321_7_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   switch(libp->paran) {
   case 5:
      G__letdouble(result7,100,(double)((const TGeoXtru*)(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 TGeoXtru*)(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 TGeoXtru*)(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 TGeoXtru*)(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_321_8_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__letint(result7,105,(long)((TGeoXtru*)(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_321_9_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      {
        const TBuffer3D& obj=((const TGeoXtru*)(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_321_0_2(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_321_1_2(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_321_2_2(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_321_3_2(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_321_4_2(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_321_5_2(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_321_6_2(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_321_7_2(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_321_8_2(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_321_9_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   G__letint(result7,85,(long)((const TGeoXtru*)(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_321_0_3(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__letint(result7,105,(long)((const TGeoXtru*)(G__getstructoffset()))->GetNmeshVertices());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_321_1_3(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((const TGeoXtru*)(G__getstructoffset()))->InspectShape();
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__Geom1_321_3_3(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_321_4_3(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   switch(libp->paran) {
   case 2:
      G__letdouble(result7,100,(double)((const TGeoXtru*)(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 TGeoXtru*)(G__getstructoffset()))->Safety((Double_t*)G__int(libp->para[0])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_321_5_3(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoXtru*)(G__getstructoffset()))->SavePrimitive(*(ofstream*)libp->para[0].ref,(Option_t*)G__int(libp->para[1]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_321_6_3(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoXtru*)(G__getstructoffset()))->SetCurrentZ((Double_t)G__double(libp->para[0]),(Int_t)G__int(libp->para[1]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_321_7_3(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((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]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_321_8_3(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoXtru*)(G__getstructoffset()))->SetDimensions((Double_t*)G__int(libp->para[0]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_321_9_3(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((const TGeoXtru*)(G__getstructoffset()))->SetPoints((Double_t*)G__int(libp->para[0]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_321_0_4(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((const TGeoXtru*)(G__getstructoffset()))->SetPoints((Float_t*)G__int(libp->para[0]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_321_1_4(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((const TGeoXtru*)(G__getstructoffset()))->SetSegsAndPols(*(TBuffer3D*)libp->para[0].ref);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_321_2_4(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((const TGeoXtru*)(G__getstructoffset()))->Sizeof3D();
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_321_3_4(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_321_4_4(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_321_5_4(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_321_6_4(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      TGeoXtru::Dictionary();
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__Geom1_321_8_4(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoXtru*)(G__getstructoffset()))->ShowMembers(*(TMemberInspector*)libp->para[0].ref,(char*)G__int(libp->para[1]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_321_9_4(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoXtru*)(G__getstructoffset()))->Streamer(*(TBuffer*)libp->para[0].ref);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_321_0_5(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoXtru*)(G__getstructoffset()))->StreamerNVirtual(*(TBuffer*)libp->para[0].ref);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_321_1_5(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_321_2_5(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_321_3_5(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_321_4_5(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 copy constructor
static int G__G__Geom1_321_5_5(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash)
{
   TGeoXtru *p;
   void *xtmp = (void*)G__int(libp->para[0]);
   p=new TGeoXtru(*(TGeoXtru*)xtmp);
   result7->obj.i = (long)p;
   result7->ref = (long)p;
   result7->type = 'u';
   result7->tagnum = G__get_linked_tagnum(&G__G__Geom1LN_TGeoXtru);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGeoXtru G__TTGeoXtru;
static int G__G__Geom1_321_6_5(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   if(0==G__getstructoffset()) return(1);
   if(G__getaryconstruct())
     if(G__PVOID==G__getgvp())
       delete[] (TGeoXtru *)(G__getstructoffset());
     else
       for(int i=G__getaryconstruct()-1;i>=0;i--)
         delete (TGeoXtru *)((G__getstructoffset())+sizeof(TGeoXtru)*i);
   else  delete (TGeoXtru *)(G__getstructoffset());
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__G__Geom1_321_7_5(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   TGeoXtru *dest = (TGeoXtru*)(G__getstructoffset());
   *dest = (*(TGeoXtru*)libp->para[0].ref);
   const TGeoXtru& obj = *dest;
   result7->ref=(long)(&obj); result7->obj.i=(long)(&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGeoHelix */
static int G__G__Geom1_323_1_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   TGeoHelix *p=NULL;
   if(G__getaryconstruct()) p=new TGeoHelix[G__getaryconstruct()];
   else                    p=new TGeoHelix;
      result7->obj.i = (long)p;
      result7->ref = (long)p;
      result7->type = 'u';
      result7->tagnum = G__get_linked_tagnum(&G__G__Geom1LN_TGeoHelix);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_323_2_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   TGeoHelix *p=NULL;
   switch(libp->paran) {
   case 3:
      p = new 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:
      p = new 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;
      result7->type = 'u';
      result7->tagnum = G__get_linked_tagnum(&G__G__Geom1LN_TGeoHelix);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_323_3_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((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]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_323_4_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoHelix*)(G__getstructoffset()))->InitPoint((Double_t*)G__int(libp->para[0]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_323_5_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   switch(libp->paran) {
   case 4:
      G__setnull(result7);
      ((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]));
      break;
   case 3:
      G__setnull(result7);
      ((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]));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__Geom1_323_7_0(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_323_8_0(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_323_9_0(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_323_0_1(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_323_1_1(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_323_2_1(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_323_3_1(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_323_4_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoHelix*)(G__getstructoffset()))->ResetStep();
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_323_5_1(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_323_6_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoHelix*)(G__getstructoffset()))->SetCharge((Int_t)G__int(libp->para[0]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_323_7_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoHelix*)(G__getstructoffset()))->SetXYcurvature((Double_t)G__double(libp->para[0]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_323_8_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   switch(libp->paran) {
   case 4:
      G__setnull(result7);
      ((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]));
      break;
   case 3:
      G__setnull(result7);
      ((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]));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_323_9_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoHelix*)(G__getstructoffset()))->SetHelixStep((Double_t)G__double(libp->para[0]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_323_0_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoHelix*)(G__getstructoffset()))->Step((Double_t)G__double(libp->para[0]));
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__Geom1_323_2_2(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_323_3_2(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_323_4_2(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_323_5_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      TGeoHelix::Dictionary();
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__Geom1_323_7_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoHelix*)(G__getstructoffset()))->ShowMembers(*(TMemberInspector*)libp->para[0].ref,(char*)G__int(libp->para[1]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_323_8_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoHelix*)(G__getstructoffset()))->Streamer(*(TBuffer*)libp->para[0].ref);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_323_9_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoHelix*)(G__getstructoffset()))->StreamerNVirtual(*(TBuffer*)libp->para[0].ref);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_323_0_3(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_323_1_3(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_323_2_3(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_323_3_3(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_323_4_3(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash)
{
   TGeoHelix *p;
   void *xtmp = (void*)G__int(libp->para[0]);
   p=new TGeoHelix(*(TGeoHelix*)xtmp);
   result7->obj.i = (long)p;
   result7->ref = (long)p;
   result7->type = 'u';
   result7->tagnum = 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_323_5_3(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   if(0==G__getstructoffset()) return(1);
   if(G__getaryconstruct())
     if(G__PVOID==G__getgvp())
       delete[] (TGeoHelix *)(G__getstructoffset());
     else
       for(int i=G__getaryconstruct()-1;i>=0;i--)
         delete (TGeoHelix *)((G__getstructoffset())+sizeof(TGeoHelix)*i);
   else  delete (TGeoHelix *)(G__getstructoffset());
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__G__Geom1_323_6_3(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_325_1_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   TGeoParaboloid *p=NULL;
   if(G__getaryconstruct()) p=new TGeoParaboloid[G__getaryconstruct()];
   else                    p=new TGeoParaboloid;
      result7->obj.i = (long)p;
      result7->ref = (long)p;
      result7->type = 'u';
      result7->tagnum = G__get_linked_tagnum(&G__G__Geom1LN_TGeoParaboloid);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_325_2_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   TGeoParaboloid *p=NULL;
      p = new 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;
      result7->type = 'u';
      result7->tagnum = G__get_linked_tagnum(&G__G__Geom1LN_TGeoParaboloid);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_325_3_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   TGeoParaboloid *p=NULL;
      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]));
      result7->obj.i = (long)p;
      result7->ref = (long)p;
      result7->type = 'u';
      result7->tagnum = G__get_linked_tagnum(&G__G__Geom1LN_TGeoParaboloid);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_325_4_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   TGeoParaboloid *p=NULL;
      p = new TGeoParaboloid((Double_t*)G__int(libp->para[0]));
      result7->obj.i = (long)p;
      result7->ref = (long)p;
      result7->type = 'u';
      result7->tagnum = G__get_linked_tagnum(&G__G__Geom1LN_TGeoParaboloid);
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__Geom1_325_6_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoParaboloid*)(G__getstructoffset()))->ComputeNormal((Double_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_325_7_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__letint(result7,103,(long)((const TGeoParaboloid*)(G__getstructoffset()))->Contains((Double_t*)G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_325_8_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__letint(result7,105,(long)((TGeoParaboloid*)(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_325_9_0(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_325_0_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   switch(libp->paran) {
   case 5:
      G__letdouble(result7,100,(double)((const TGeoParaboloid*)(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 TGeoParaboloid*)(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 TGeoParaboloid*)(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 TGeoParaboloid*)(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_325_1_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   switch(libp->paran) {
   case 5:
      G__letdouble(result7,100,(double)((const TGeoParaboloid*)(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 TGeoParaboloid*)(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 TGeoParaboloid*)(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 TGeoParaboloid*)(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_325_2_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   G__letint(result7,85,(long)((TGeoParaboloid*)(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_325_3_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      {
        const TBuffer3D& obj=((const TGeoParaboloid*)(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_325_4_1(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_325_5_1(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_325_6_1(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_325_7_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((const TGeoParaboloid*)(G__getstructoffset()))->GetBoundingCylinder((Double_t*)G__int(libp->para[0]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_325_8_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   G__letint(result7,85,(long)((const TGeoParaboloid*)(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_325_9_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__letint(result7,105,(long)((const TGeoParaboloid*)(G__getstructoffset()))->GetNmeshVertices());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_325_0_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((const TGeoParaboloid*)(G__getstructoffset()))->InspectShape();
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_325_1_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__letint(result7,103,(long)((const TGeoParaboloid*)(G__getstructoffset()))->IsCylType());
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__Geom1_325_3_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   switch(libp->paran) {
   case 2:
      G__letdouble(result7,100,(double)((const TGeoParaboloid*)(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 TGeoParaboloid*)(G__getstructoffset()))->Safety((Double_t*)G__int(libp->para[0])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_325_4_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoParaboloid*)(G__getstructoffset()))->SavePrimitive(*(ofstream*)libp->para[0].ref,(Option_t*)G__int(libp->para[1]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_325_5_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((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]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_325_6_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoParaboloid*)(G__getstructoffset()))->SetDimensions((Double_t*)G__int(libp->para[0]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_325_7_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((const TGeoParaboloid*)(G__getstructoffset()))->SetPoints((Double_t*)G__int(libp->para[0]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_325_8_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((const TGeoParaboloid*)(G__getstructoffset()))->SetPoints((Float_t*)G__int(libp->para[0]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_325_9_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((const TGeoParaboloid*)(G__getstructoffset()))->SetSegsAndPols(*(TBuffer3D*)libp->para[0].ref);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_325_0_3(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((const TGeoParaboloid*)(G__getstructoffset()))->Sizeof3D();
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_325_1_3(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_325_2_3(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_325_3_3(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_325_4_3(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      TGeoParaboloid::Dictionary();
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__Geom1_325_6_3(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoParaboloid*)(G__getstructoffset()))->ShowMembers(*(TMemberInspector*)libp->para[0].ref,(char*)G__int(libp->para[1]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_325_7_3(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoParaboloid*)(G__getstructoffset()))->Streamer(*(TBuffer*)libp->para[0].ref);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_325_8_3(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoParaboloid*)(G__getstructoffset()))->StreamerNVirtual(*(TBuffer*)libp->para[0].ref);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_325_9_3(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_325_0_4(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_325_1_4(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_325_2_4(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_325_3_4(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash)
{
   TGeoParaboloid *p;
   void *xtmp = (void*)G__int(libp->para[0]);
   p=new TGeoParaboloid(*(TGeoParaboloid*)xtmp);
   result7->obj.i = (long)p;
   result7->ref = (long)p;
   result7->type = 'u';
   result7->tagnum = 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_325_4_4(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   if(0==G__getstructoffset()) return(1);
   if(G__getaryconstruct())
     if(G__PVOID==G__getgvp())
       delete[] (TGeoParaboloid *)(G__getstructoffset());
     else
       for(int i=G__getaryconstruct()-1;i>=0;i--)
         delete (TGeoParaboloid *)((G__getstructoffset())+sizeof(TGeoParaboloid)*i);
   else  delete (TGeoParaboloid *)(G__getstructoffset());
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__G__Geom1_325_5_4(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_326_1_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   TGeoHalfSpace *p=NULL;
   if(G__getaryconstruct()) p=new TGeoHalfSpace[G__getaryconstruct()];
   else                    p=new TGeoHalfSpace;
      result7->obj.i = (long)p;
      result7->ref = (long)p;
      result7->type = 'u';
      result7->tagnum = G__get_linked_tagnum(&G__G__Geom1LN_TGeoHalfSpace);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_326_2_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   TGeoHalfSpace *p=NULL;
      p = new 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;
      result7->type = 'u';
      result7->tagnum = G__get_linked_tagnum(&G__G__Geom1LN_TGeoHalfSpace);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_326_3_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   TGeoHalfSpace *p=NULL;
      p = new TGeoHalfSpace((Double_t*)G__int(libp->para[0]));
      result7->obj.i = (long)p;
      result7->ref = (long)p;
      result7->type = 'u';
      result7->tagnum = G__get_linked_tagnum(&G__G__Geom1LN_TGeoHalfSpace);
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__Geom1_326_5_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoHalfSpace*)(G__getstructoffset()))->ComputeNormal((Double_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_326_6_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__letint(result7,103,(long)((const TGeoHalfSpace*)(G__getstructoffset()))->Contains((Double_t*)G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_326_7_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__letint(result7,105,(long)((TGeoHalfSpace*)(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_326_8_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   switch(libp->paran) {
   case 5:
      G__letdouble(result7,100,(double)((const TGeoHalfSpace*)(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 TGeoHalfSpace*)(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 TGeoHalfSpace*)(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 TGeoHalfSpace*)(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_326_9_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   switch(libp->paran) {
   case 5:
      G__letdouble(result7,100,(double)((const TGeoHalfSpace*)(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 TGeoHalfSpace*)(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 TGeoHalfSpace*)(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 TGeoHalfSpace*)(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_326_0_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   G__letint(result7,85,(long)((TGeoHalfSpace*)(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_326_1_1(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_326_2_1(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_326_3_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((const TGeoHalfSpace*)(G__getstructoffset()))->GetBoundingCylinder((Double_t*)G__int(libp->para[0]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_326_4_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   G__letint(result7,85,(long)((const TGeoHalfSpace*)(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_326_5_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__letint(result7,105,(long)((const TGeoHalfSpace*)(G__getstructoffset()))->GetNmeshVertices());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_326_6_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((const TGeoHalfSpace*)(G__getstructoffset()))->InspectShape();
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_326_7_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__letint(result7,103,(long)((const TGeoHalfSpace*)(G__getstructoffset()))->IsCylType());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_326_8_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   switch(libp->paran) {
   case 2:
      G__letdouble(result7,100,(double)((const TGeoHalfSpace*)(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 TGeoHalfSpace*)(G__getstructoffset()))->Safety((Double_t*)G__int(libp->para[0])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_326_9_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoHalfSpace*)(G__getstructoffset()))->SavePrimitive(*(ofstream*)libp->para[0].ref,(Option_t*)G__int(libp->para[1]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_326_0_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoHalfSpace*)(G__getstructoffset()))->SetDimensions((Double_t*)G__int(libp->para[0]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_326_1_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((const TGeoHalfSpace*)(G__getstructoffset()))->SetPoints((Double_t*)G__int(libp->para[0]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_326_2_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((const TGeoHalfSpace*)(G__getstructoffset()))->SetPoints((Float_t*)G__int(libp->para[0]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_326_3_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((const TGeoHalfSpace*)(G__getstructoffset()))->Sizeof3D();
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_326_4_2(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_326_5_2(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_326_6_2(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_326_7_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      TGeoHalfSpace::Dictionary();
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__Geom1_326_9_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoHalfSpace*)(G__getstructoffset()))->ShowMembers(*(TMemberInspector*)libp->para[0].ref,(char*)G__int(libp->para[1]));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_326_0_3(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoHalfSpace*)(G__getstructoffset()))->Streamer(*(TBuffer*)libp->para[0].ref);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_326_1_3(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__setnull(result7);
      ((TGeoHalfSpace*)(G__getstructoffset()))->StreamerNVirtual(*(TBuffer*)libp->para[0].ref);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_326_2_3(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_326_3_3(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_326_4_3(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_326_5_3(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_326_6_3(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash)
{
   TGeoHalfSpace *p;
   void *xtmp = (void*)G__int(libp->para[0]);
   p=new TGeoHalfSpace(*(TGeoHalfSpace*)xtmp);
   result7->obj.i = (long)p;
   result7->ref = (long)p;
   result7->type = 'u';
   result7->tagnum = 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_326_7_3(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   if(0==G__getstructoffset()) return(1);
   if(G__getaryconstruct())
     if(G__PVOID==G__getgvp())
       delete[] (TGeoHalfSpace *)(G__getstructoffset());
     else
       for(int i=G__getaryconstruct()-1;i>=0;i--)
         delete (TGeoHalfSpace *)((G__getstructoffset())+sizeof(TGeoHalfSpace)*i);
   else  delete (TGeoHalfSpace *)(G__getstructoffset());
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__G__Geom1_326_8_3(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) ;
}


/* Setting up global function */

/*********************************************************
* Member function Stub
*********************************************************/

/* TGeoAtt */

/* TGeoShape */

/* TGeoMatrix */

/* TGeoHMatrix */

/* TGeoBoolNode */

/* TGeoUnion */

/* TGeoIntersection */

/* TGeoSubtraction */

/* TGeoElementTable */

/* TGeoElement */

/* TGeoMaterial */

/* TGeoMixture */

/* TGeoMedium */

/* TGeoTranslation */

/* TGeoRotation */

/* TGeoScale */

/* TGeoCombiTrans */

/* TGeoGenTrans */

/* TGeoIdentity */

/* TGeoBBox */

/* TGeoVolume */

/* TGeoNode */

/* TGeoVoxelFinder */

/* TGeoManager */

/* TGeoVolumeMulti */

/* TGeoVolumeAssembly */

/* TGeoCylVoxels */

/* TGeoFullVoxels */

/* TGeoNodeMatrix */

/* TGeoNodeOffset */

/* TGeoPara */

/* TGeoTube */

/* TGeoTubeSeg */

/* TGeoCtub */

/* TGeoTorus */

/* TGeoSphere */

/* TGeoEltu */

/* TGeoHype */

/* TGeoCone */

/* TGeoConeSeg */

/* TGeoPcon */

/* TGeoPgon */

/* TGeoArb8 */

/* TGeoTrap */

/* TGeoGtra */

/* TGeoTrd1 */

/* TGeoTrd2 */

/* TVirtualGeoTrack */

/* TGeoPhysicalNode */

/* TVirtualGeoPainter */

/* TGeoCompositeShape */

/* TGeoPolygon */

/* TGeoXtru */

/* TGeoHelix */

/* TGeoParaboloid */

/* TGeoHalfSpace */

/*********************************************************
* 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_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_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_TGeoCylVoxels))) {
     TGeoCylVoxels *G__Lderived;
     G__Lderived=(TGeoCylVoxels*)0x1000;
     {
       TGeoVoxelFinder *G__Lpbase=(TGeoVoxelFinder*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoCylVoxels),G__get_linked_tagnum(&G__G__Geom1LN_TGeoVoxelFinder),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoCylVoxels),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_TGeoFullVoxels))) {
     TGeoFullVoxels *G__Lderived;
     G__Lderived=(TGeoFullVoxels*)0x1000;
     {
       TGeoVoxelFinder *G__Lpbase=(TGeoVoxelFinder*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoFullVoxels),G__get_linked_tagnum(&G__G__Geom1LN_TGeoVoxelFinder),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoFullVoxels),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_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_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_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;
     {
       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,1);
     }
     {
       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_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_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);
     }
   }
}

/*********************************************************
* 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("vector<TStreamerInfo*>",117,G__get_linked_tagnum(&G__G__Geom1LN_vectorlETStreamerInfomUcOallocatorlETStreamerInfomUgRsPgR),0,-1);
   G__setnewtype(-1,"// @(#)root/base:$Name: v4-04-02b $:$Id: TROOT.h,v 1.42.4.1 2005/06/03 14:59:00 rdm Exp $",0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__Geom1LN_reverse_iteratorlEvectorlETStreamerInfomUcOallocatorlETStreamerInfomUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__Geom1LN_vectorlETStreamerInfomUcOallocatorlETStreamerInfomUgRsPgR));
   G__setnewtype(-1,"// @(#)root/base:$Name: v4-04-02b $:$Id: TROOT.h,v 1.42.4.1 2005/06/03 14:59:00 rdm Exp $",0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__Geom1LN_reverse_iteratorlEvectorlETStreamerInfomUcOallocatorlETStreamerInfomUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__Geom1LN_vectorlETStreamerInfomUcOallocatorlETStreamerInfomUgRsPgR));
   G__setnewtype(-1,"// @(#)root/base:$Name: v4-04-02b $:$Id: TROOT.h,v 1.42.4.1 2005/06/03 14:59:00 rdm Exp $",0);
   G__search_typename2("Style_t",115,-1,0,
-1);
   G__setnewtype(-1,"Style number (short)",0);
   G__search_typename2("Width_t",115,-1,0,
-1);
   G__setnewtype(-1,"Line width (short)",0);
   G__search_typename2("Color_t",115,-1,0,
-1);
   G__setnewtype(-1,"Color number (short)",0);
   G__search_typename2("vector<UInt_t>",117,G__get_linked_tagnum(&G__G__Geom1LN_vectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgR),0,-1);
   G__setnewtype(-1,"// @(#)root/base:$Name: v4-04-02b $:$Id: TROOT.h,v 1.42.4.1 2005/06/03 14:59:00 rdm Exp $",0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__Geom1LN_reverse_iteratorlEvectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__Geom1LN_vectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgR));
   G__setnewtype(-1,"// @(#)root/base:$Name: v4-04-02b $:$Id: TROOT.h,v 1.42.4.1 2005/06/03 14:59:00 rdm Exp $",0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__Geom1LN_reverse_iteratorlEvectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__Geom1LN_vectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgR));
   G__setnewtype(-1,"// @(#)root/base:$Name: v4-04-02b $:$Id: TROOT.h,v 1.42.4.1 2005/06/03 14:59:00 rdm Exp $",0);
   G__search_typename2("vector<unsigned int>",117,G__get_linked_tagnum(&G__G__Geom1LN_vectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgR),0,-1);
   G__setnewtype(-1,"// @(#)root/base:$Name: v4-04-02b $:$Id: TROOT.h,v 1.42.4.1 2005/06/03 14:59:00 rdm Exp $",0);
   G__search_typename2("vector<TString>",117,G__get_linked_tagnum(&G__G__Geom1LN_vectorlETStringcOallocatorlETStringgRsPgR),0,-1);
   G__setnewtype(-1,"// @(#)root/base:$Name: v4-04-02b $:$Id: TROOT.h,v 1.42.4.1 2005/06/03 14:59:00 rdm Exp $",0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__Geom1LN_reverse_iteratorlEvectorlETStringcOallocatorlETStringgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__Geom1LN_vectorlETStringcOallocatorlETStringgRsPgR));
   G__setnewtype(-1,"// @(#)root/base:$Name: v4-04-02b $:$Id: TROOT.h,v 1.42.4.1 2005/06/03 14:59:00 rdm Exp $",0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__Geom1LN_reverse_iteratorlEvectorlETStringcOallocatorlETStringgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__Geom1LN_vectorlETStringcOallocatorlETStringgRsPgR));
   G__setnewtype(-1,"// @(#)root/base:$Name: v4-04-02b $:$Id: TROOT.h,v 1.42.4.1 2005/06/03 14:59:00 rdm Exp $",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,"kBitMask=16777215",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Geom1LN_TGeoAttcLcLEGeoVisibilityAtt),-1,-2,1,"kVisOverride=1",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Geom1LN_TGeoAttcLcLEGeoVisibilityAtt),-1,-2,1,"kVisNone=2",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Geom1LN_TGeoAttcLcLEGeoVisibilityAtt),-1,-2,1,"kVisThis=4",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Geom1LN_TGeoAttcLcLEGeoVisibilityAtt),-1,-2,1,"kVisDaughters=8",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Geom1LN_TGeoAttcLcLEGeoVisibilityAtt),-1,-2,1,"kVisOneLevel=16",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Geom1LN_TGeoAttcLcLEGeoVisibilityAtt),-1,-2,1,"kVisStreamed=32",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Geom1LN_TGeoAttcLcLEGeoVisibilityAtt),-1,-2,1,"kVisTouched=64",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Geom1LN_TGeoAttcLcLEGeoVisibilityAtt),-1,-2,1,"kVisOnScreen=128",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Geom1LN_TGeoAttcLcLEGeoActivityAtt),-1,-2,1,"kActOverride=256",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Geom1LN_TGeoAttcLcLEGeoActivityAtt),-1,-2,1,"kActNone=512",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Geom1LN_TGeoAttcLcLEGeoActivityAtt),-1,-2,1,"kActThis=1024",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Geom1LN_TGeoAttcLcLEGeoActivityAtt),-1,-2,1,"kActDaughters=2048",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Geom1LN_TGeoAttcLcLEGeoOptimizationAtt),-1,-2,1,"kUseBoundingBox=65536",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Geom1LN_TGeoAttcLcLEGeoOptimizationAtt),-1,-2,1,"kUseVoxels=131072",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Geom1LN_TGeoAttcLcLEGeoOptimizationAtt),-1,-2,1,"kUseGsord=262144",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Geom1LN_TGeoAttcLcLEGeoSavePrimitiveAtt),-1,-2,1,"kSavePrimitiveAtt=524288",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Geom1LN_TGeoAttcLcLEGeoSavePrimitiveAtt),-1,-2,1,"kSaveNodesAtt=1048576",0,(char*)NULL);
   G__memvar_setup((void*)NULL,104,0,0,-1,G__defined_typename("UInt_t"),-1,2,"fGeoAtt=",0,"option flags");
   G__memvar_setup((void*)NULL,108,0,0,-1,-1,-1,4,"G__virtualinfo=",0,(char*)NULL);
   G__memvar_setup((void*)NULL,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*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Geom1LN_TGeoShapecLcLEShapeType),-1,-2,1,"kBitMask32=-1",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Geom1LN_TGeoShapecLcLEShapeType),-1,-2,1,"kGeoNoShape=0",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Geom1LN_TGeoShapecLcLEShapeType),-1,-2,1,"kGeoBad=1",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Geom1LN_TGeoShapecLcLEShapeType),-1,-2,1,"kGeoRSeg=2",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Geom1LN_TGeoShapecLcLEShapeType),-1,-2,1,"kGeoPhiSeg=4",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Geom1LN_TGeoShapecLcLEShapeType),-1,-2,1,"kGeoThetaSeg=8",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Geom1LN_TGeoShapecLcLEShapeType),-1,-2,1,"kGeoVisX=16",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Geom1LN_TGeoShapecLcLEShapeType),-1,-2,1,"kGeoVisY=32",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Geom1LN_TGeoShapecLcLEShapeType),-1,-2,1,"kGeoVisZ=64",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Geom1LN_TGeoShapecLcLEShapeType),-1,-2,1,"kGeoRunTimeShape=128",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Geom1LN_TGeoShapecLcLEShapeType),-1,-2,1,"kGeoInvalidShape=256",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Geom1LN_TGeoShapecLcLEShapeType),-1,-2,1,"kGeoTorus=512",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Geom1LN_TGeoShapecLcLEShapeType),-1,-2,1,"kGeoBox=1024",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Geom1LN_TGeoShapecLcLEShapeType),-1,-2,1,"kGeoPara=2048",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Geom1LN_TGeoShapecLcLEShapeType),-1,-2,1,"kGeoSph=4096",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Geom1LN_TGeoShapecLcLEShapeType),-1,-2,1,"kGeoTube=8192",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Geom1LN_TGeoShapecLcLEShapeType),-1,-2,1,"kGeoTubeSeg=16384",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Geom1LN_TGeoShapecLcLEShapeType),-1,-2,1,"kGeoCone=32768",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Geom1LN_TGeoShapecLcLEShapeType),-1,-2,1,"kGeoConeSeg=65536",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Geom1LN_TGeoShapecLcLEShapeType),-1,-2,1,"kGeoPcon=131072",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Geom1LN_TGeoShapecLcLEShapeType),-1,-2,1,"kGeoPgon=262144",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Geom1LN_TGeoShapecLcLEShapeType),-1,-2,1,"kGeoArb8=524288",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Geom1LN_TGeoShapecLcLEShapeType),-1,-2,1,"kGeoEltu=1048576",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Geom1LN_TGeoShapecLcLEShapeType),-1,-2,1,"kGeoTrap=2097152",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Geom1LN_TGeoShapecLcLEShapeType),-1,-2,1,"kGeoCtub=4194304",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Geom1LN_TGeoShapecLcLEShapeType),-1,-2,1,"kGeoTrd1=8388608",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Geom1LN_TGeoShapecLcLEShapeType),-1,-2,1,"kGeoTrd2=16777216",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Geom1LN_TGeoShapecLcLEShapeType),-1,-2,1,"kGeoComb=33554432",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Geom1LN_TGeoShapecLcLEShapeType),-1,-2,1,"kGeoClosedShape=67108864",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Geom1LN_TGeoShapecLcLEShapeType),-1,-2,1,"kGeoXtru=134217728",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Geom1LN_TGeoShapecLcLEShapeType),-1,-2,1,"kGeoParaboloid=268435456",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Geom1LN_TGeoShapecLcLEShapeType),-1,-2,1,"kGeoHalfSpace=536870912",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Geom1LN_TGeoShapecLcLEShapeType),-1,-2,1,"kGeoHype=1073741824",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Geom1LN_TGeoShapecLcLEShapeType),-1,-2,1,"kGeoSavePrimitive=1048576",0,(char*)NULL);
   G__memvar_setup((void*)NULL,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fShapeId=",0,"shape id");
   G__memvar_setup((void*)NULL,104,0,0,-1,G__defined_typename("UInt_t"),-1,2,"fShapeBits=",0,"shape bits");
   G__memvar_setup((void*)NULL,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,"kGeoIdentity=0",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Geom1LN_TGeoMatrixcLcLEGeoTransfTypes),-1,-2,1,"kGeoTranslation=131072",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Geom1LN_TGeoMatrixcLcLEGeoTransfTypes),-1,-2,1,"kGeoRotation=262144",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Geom1LN_TGeoMatrixcLcLEGeoTransfTypes),-1,-2,1,"kGeoScale=524288",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Geom1LN_TGeoMatrixcLcLEGeoTransfTypes),-1,-2,1,"kGeoReflection=1048576",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Geom1LN_TGeoMatrixcLcLEGeoTransfTypes),-1,-2,1,"kGeoRegistered=2097152",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Geom1LN_TGeoMatrixcLcLEGeoTransfTypes),-1,-2,1,"kGeoSavePrimitive=4194304",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Geom1LN_TGeoMatrixcLcLEGeoTransfTypes),-1,-2,1,"kGeoMatrixOwned=8388608",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Geom1LN_TGeoMatrixcLcLEGeoTransfTypes),-1,-2,1,"kGeoCombiTrans=393216",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Geom1LN_TGeoMatrixcLcLEGeoTransfTypes),-1,-2,1,"kGeoGenTrans=917504",0,(char*)NULL);
   G__memvar_setup((void*)NULL,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*)NULL,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fTranslation[3]=",0,"translation component");
   G__memvar_setup((void*)NULL,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fRotationMatrix[9]=",0,"rotation matrix");
   G__memvar_setup((void*)NULL,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fScale[3]=",0,"scale component");
   G__memvar_setup((void*)NULL,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,"kGeoUnion=0",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Geom1LN_TGeoBoolNodecLcLEGeoBoolType),-1,-2,1,"kGeoIntersection=1",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Geom1LN_TGeoBoolNodecLcLEGeoBoolType),-1,-2,1,"kGeoSubtraction=2",0,(char*)NULL);
   G__memvar_setup((void*)NULL,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fSelected=",0,"! selected branch");
   G__memvar_setup((void*)NULL,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*)NULL,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*)NULL,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*)NULL,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*)NULL,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*)NULL,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*)NULL,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*)NULL,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*)NULL,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fNelements=",0,"number of elements");
   G__memvar_setup((void*)NULL,85,0,0,G__get_linked_tagnum(&G__G__Geom1LN_TObjArray),-1,-1,4,"fList=",0,"list of elements");
   G__memvar_setup((void*)NULL,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,1,"kElemUsed=131072",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Geom1LN_TGeoElementcLcLEGeoElement),-1,-2,1,"kElemDefined=262144",0,(char*)NULL);
   G__memvar_setup((void*)NULL,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fZ=",0,"Z of material");
   G__memvar_setup((void*)NULL,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fA=",0,"A of material");
   G__memvar_setup((void*)NULL,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,"kMatUsed=131072",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Geom1LN_TGeoMaterialcLcLEGeoMaterial),-1,-2,1,"kMatSavePrimitive=262144",0,(char*)NULL);
   G__memvar_setup((void*)NULL,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fIndex=",0,"material index");
   G__memvar_setup((void*)NULL,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fA=",0,"A of material");
   G__memvar_setup((void*)NULL,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fZ=",0,"Z of material");
   G__memvar_setup((void*)NULL,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fDensity=",0,"density of material");
   G__memvar_setup((void*)NULL,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fRadLen=",0,"radiation length");
   G__memvar_setup((void*)NULL,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fIntLen=",0,"interaction length");
   G__memvar_setup((void*)NULL,85,0,0,G__get_linked_tagnum(&G__G__Geom1LN_TObject),-1,-1,2,"fShader=",0,"shader with optical properties");
   G__memvar_setup((void*)NULL,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*)NULL,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*)NULL,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fNelements=",0,"number of elements");
   G__memvar_setup((void*)NULL,68,0,0,-1,G__defined_typename("Double_t"),-1,2,"fZmixture=",0,"[fNelements] array of Z of the elements");
   G__memvar_setup((void*)NULL,68,0,0,-1,G__defined_typename("Double_t"),-1,2,"fAmixture=",0,"[fNelements] array of A of the elements");
   G__memvar_setup((void*)NULL,68,0,0,-1,G__defined_typename("Double_t"),-1,2,"fWeights=",0,"[fNelements] array of relative proportions by mass");
   G__memvar_setup((void*)NULL,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,"kMedSavePrimitive=262144",0,(char*)NULL);
   G__memvar_setup((void*)NULL,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fId=",0,"unique Id");
   G__memvar_setup((void*)NULL,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fParams[20]=",0,"parameters");
   G__memvar_setup((void*)NULL,85,0,0,G__get_linked_tagnum(&G__G__Geom1LN_TGeoMaterial),-1,-1,2,"fMaterial=",0,"pointer to material");
   G__memvar_setup((void*)NULL,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*)NULL,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fTranslation[3]=",0,"translation vector");
   G__memvar_setup((void*)NULL,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*)NULL,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fRotationMatrix[9]=",0,"rotation matrix");
   G__memvar_setup((void*)NULL,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*)NULL,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fScale[3]=",0,"scale (x, y, z)");
   G__memvar_setup((void*)NULL,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*)NULL,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fTranslation[3]=",0,"translation vector");
   G__memvar_setup((void*)NULL,85,0,0,G__get_linked_tagnum(&G__G__Geom1LN_TGeoRotation),-1,-1,2,"fRotation=",0,"rotation matrix");
   G__memvar_setup((void*)NULL,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*)NULL,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fScale[3]=",0,"scale (x, y, z)");
   G__memvar_setup((void*)NULL,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*)NULL,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*)NULL,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fDX=",0,"X half-length");
   G__memvar_setup((void*)NULL,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fDY=",0,"Y half-length");
   G__memvar_setup((void*)NULL,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fDZ=",0,"Z half-length");
   G__memvar_setup((void*)NULL,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fOrigin[3]=",0,"box origin");
   G__memvar_setup((void*)NULL,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*)NULL,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*)NULL,85,0,0,G__get_linked_tagnum(&G__G__Geom1LN_TGeoShape),-1,-1,2,"fShape=",0,"shape");
   G__memvar_setup((void*)NULL,85,0,0,G__get_linked_tagnum(&G__G__Geom1LN_TGeoMedium),-1,-1,2,"fMedium=",0,"tracking medium");
   G__memvar_setup((void*)NULL,85,0,0,G__get_linked_tagnum(&G__G__Geom1LN_TGeoPatternFinder),-1,-1,2,"fFinder=",0,"finder object for divisions");
   G__memvar_setup((void*)NULL,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*)NULL,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*)NULL,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*)NULL,117,0,0,G__get_linked_tagnum(&G__G__Geom1LN_TString),-1,-1,2,"fOption=",0,"! option - if any");
   G__memvar_setup((void*)NULL,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*)NULL,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,"kVolumeDiv=65536",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Geom1LN_TGeoVolumecLcLEGeoVolumeTypes),-1,-2,1,"kVolumeOverlap=131072",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Geom1LN_TGeoVolumecLcLEGeoVolumeTypes),-1,-2,1,"kVolumeImportNodes=262144",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Geom1LN_TGeoVolumecLcLEGeoVolumeTypes),-1,-2,1,"kVolumeMulti=524288",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Geom1LN_TGeoVolumecLcLEGeoVolumeTypes),-1,-2,1,"kVoxelsXYZ=1048576",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Geom1LN_TGeoVolumecLcLEGeoVolumeTypes),-1,-2,1,"kVoxelsCyl=2097152",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Geom1LN_TGeoVolumecLcLEGeoVolumeTypes),-1,-2,1,"kVolumeClone=4194304",0,(char*)NULL);
   G__memvar_setup((void*)NULL,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*)NULL,85,0,0,G__get_linked_tagnum(&G__G__Geom1LN_TGeoVolume),-1,-1,2,"fVolume=",0,"volume associated with this");
   G__memvar_setup((void*)NULL,85,0,0,G__get_linked_tagnum(&G__G__Geom1LN_TGeoVolume),-1,-1,2,"fMother=",0,"mother volume");
   G__memvar_setup((void*)NULL,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fNumber=",0,"copy number");
   G__memvar_setup((void*)NULL,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fNovlp=",0,"number of overlaps");
   G__memvar_setup((void*)NULL,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,"kGeoNodeMatrix=1024",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Geom1LN_TGeoNodecLcLdA),-1,-2,1,"kGeoNodeOffset=2048",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Geom1LN_TGeoNodecLcLdA),-1,-2,1,"kGeoNodeVC=4096",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Geom1LN_TGeoNodecLcLdA),-1,-2,1,"kGeoNodeOverlap=8192",0,(char*)NULL);
   G__memvar_setup((void*)NULL,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,"kGeoInvalidVoxels=32768",0,(char*)NULL);
   G__memvar_setup((void*)NULL,85,0,0,G__get_linked_tagnum(&G__G__Geom1LN_TGeoVolume),-1,-1,2,"fVolume=",0,"volume to which applies");
   G__memvar_setup((void*)NULL,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fNcandidates=",0,"! number of candidates");
   G__memvar_setup((void*)NULL,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fCurrentVoxel=",0,"! index of current voxel in sorted list");
   G__memvar_setup((void*)NULL,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fIbx=",0,"number of different boundaries on X axis");
   G__memvar_setup((void*)NULL,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fIby=",0,"number of different boundaries on Y axis");
   G__memvar_setup((void*)NULL,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fIbz=",0,"number of different boundaries on Z axis");
   G__memvar_setup((void*)NULL,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fNboxes=",0,"length of boxes array");
   G__memvar_setup((void*)NULL,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fNox=",0,"length of array of X offsets");
   G__memvar_setup((void*)NULL,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fNoy=",0,"length of array of Y offsets");
   G__memvar_setup((void*)NULL,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fNoz=",0,"length of array of Z offsets");
   G__memvar_setup((void*)NULL,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fNex=",0,"length of array of X extra offsets");
   G__memvar_setup((void*)NULL,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fNey=",0,"length of array of Y extra offsets");
   G__memvar_setup((void*)NULL,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fNez=",0,"length of array of Z extra offsets");
   G__memvar_setup((void*)NULL,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fNx=",0,"length of array of X voxels");
   G__memvar_setup((void*)NULL,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fNy=",0,"length of array of Y voxels");
   G__memvar_setup((void*)NULL,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fNz=",0,"length of array of Z voxels");
   G__memvar_setup((void*)NULL,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fPriority[3]=",0,"priority for each axis");
   G__memvar_setup((void*)NULL,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fSlices[3]=",0,"! slice indices for current voxel");
   G__memvar_setup((void*)NULL,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fInc[3]=",0,"! slice index increment");
   G__memvar_setup((void*)NULL,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fInvdir[3]=",0,"! 1/current director cosines");
   G__memvar_setup((void*)NULL,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fLimits[3]=",0,"limits on X,Y,Z");
   G__memvar_setup((void*)NULL,68,0,0,-1,G__defined_typename("Double_t"),-1,2,"fBoxes=",0,"[fNboxes] list of bounding boxes");
   G__memvar_setup((void*)NULL,68,0,0,-1,G__defined_typename("Double_t"),-1,2,"fXb=",0,"[fIbx] ordered array of X box boundaries");
   G__memvar_setup((void*)NULL,68,0,0,-1,G__defined_typename("Double_t"),-1,2,"fYb=",0,"[fIby] ordered array of Y box boundaries");
   G__memvar_setup((void*)NULL,68,0,0,-1,G__defined_typename("Double_t"),-1,2,"fZb=",0,"[fIbz] ordered array of Z box boundaries");
   G__memvar_setup((void*)NULL,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*)NULL,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*)NULL,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*)NULL,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*)NULL,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*)NULL,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*)NULL,73,0,0,-1,G__defined_typename("Int_t"),-1,2,"fIndX=",0,"[fNx] indices of daughters inside boundaries X");
   G__memvar_setup((void*)NULL,73,0,0,-1,G__defined_typename("Int_t"),-1,2,"fIndY=",0,"[fNy] indices of daughters inside boundaries Y");
   G__memvar_setup((void*)NULL,73,0,0,-1,G__defined_typename("Int_t"),-1,2,"fIndZ=",0,"[fNz] indices of daughters inside boundaries Z");
   G__memvar_setup((void*)NULL,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*)NULL,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*)NULL,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*)NULL,73,0,0,-1,G__defined_typename("Int_t"),-1,2,"fCheckList=",0,"! list of candidates");
   G__memvar_setup((void*)NULL,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*)NULL,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*)NULL,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fSafety=",0,"! safety radius from current point");
   G__memvar_setup((void*)NULL,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fLastSafety=",0,"! last computed safety radius");
   G__memvar_setup((void*)NULL,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fPhimin=",0,"! lowest range for phi cut");
   G__memvar_setup((void*)NULL,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fPhimax=",0,"! highest range for phi cut");
   G__memvar_setup((void*)NULL,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fTmin=",0,"! lower time limit for tracks drawing");
   G__memvar_setup((void*)NULL,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fTmax=",0,"! upper time limit for tracks drawing");
   G__memvar_setup((void*)NULL,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fLevel=",0,"! current geometry level;");
   G__memvar_setup((void*)NULL,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fNNodes=",0,"total number of physical nodes");
   G__memvar_setup((void*)NULL,117,0,0,G__get_linked_tagnum(&G__G__Geom1LN_TString),-1,-1,4,"fPath=",0,"! path to current node");
   G__memvar_setup((void*)NULL,117,0,0,G__get_linked_tagnum(&G__G__Geom1LN_TString),-1,-1,4,"fParticleName=",0,"! particles to be drawn");
   G__memvar_setup((void*)NULL,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*)NULL,68,0,0,-1,G__defined_typename("Double_t"),-1,4,"fCldir=",0,"! unit vector to current closest shape");
   G__memvar_setup((void*)NULL,68,0,0,-1,G__defined_typename("Double_t"),-1,4,"fCldirChecked=",0,"! unit vector to current checked shape");
   G__memvar_setup((void*)NULL,68,0,0,-1,G__defined_typename("Double_t"),-1,4,"fPoint=",0,"![3] current point");
   G__memvar_setup((void*)NULL,68,0,0,-1,G__defined_typename("Double_t"),-1,4,"fDirection=",0,"![3] current direction");
   G__memvar_setup((void*)NULL,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fVisDensity=",0,"transparency threshold by density");
   G__memvar_setup((void*)NULL,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fExplodedView=",0,"exploded view mode");
   G__memvar_setup((void*)NULL,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fVisOption=",0,"global visualization option");
   G__memvar_setup((void*)NULL,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fVisLevel=",0,"maximum visualization depth");
   G__memvar_setup((void*)NULL,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fNsegments=",0,"number of segments to approximate circles");
   G__memvar_setup((void*)NULL,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fNtracks=",0,"number of tracks");
   G__memvar_setup((void*)NULL,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fMaxVisNodes=",0,"maximum number of visible nodes");
   G__memvar_setup((void*)NULL,85,0,0,G__get_linked_tagnum(&G__G__Geom1LN_TVirtualGeoTrack),-1,-1,4,"fCurrentTrack=",0,"! current track");
   G__memvar_setup((void*)NULL,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fNpdg=",0,"number of different pdg's stored");
   G__memvar_setup((void*)NULL,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fPdgId[256]=",0,"pdg conversion table");
   G__memvar_setup((void*)NULL,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*)NULL,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fCurrentOverlapping=",0,"! flags the type of the current node");
   G__memvar_setup((void*)NULL,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fLoopVolumes=",0,"! flag volume lists loop");
   G__memvar_setup((void*)NULL,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fStartSafe=",0,"! flag a safe start for point classification");
   G__memvar_setup((void*)NULL,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*)NULL,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*)NULL,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*)NULL,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*)NULL,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fIsOutside=",0,"! flag that current point is outside geometry");
   G__memvar_setup((void*)NULL,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*)NULL,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*)NULL,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fIsNullStep=",0,"! flag that last geometric step was null");
   G__memvar_setup((void*)NULL,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fStreamVoxels=",0,"flag to allow voxelization I/O");
   G__memvar_setup((void*)NULL,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fIsGeomReading=",0,"! flag set when reading geometry");
   G__memvar_setup((void*)NULL,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fPhiCut=",0,"flag for phi cuts");
   G__memvar_setup((void*)NULL,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fTimeCut=",0,"time cut for tracks");
   G__memvar_setup((void*)NULL,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*)NULL,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fMatrixTransform=",0,"! flag for using GL matrix");
   G__memvar_setup((void*)NULL,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fMatrixReflection=",0,"! flag for GL reflections");
   G__memvar_setup((void*)NULL,85,0,0,G__get_linked_tagnum(&G__G__Geom1LN_TGeoNodeCache),-1,-1,4,"fCache=",0,"! cache for physical nodes");
   G__memvar_setup((void*)NULL,85,0,0,G__get_linked_tagnum(&G__G__Geom1LN_TVirtualGeoPainter),-1,-1,4,"fPainter=",0,"! current painter");
   G__memvar_setup((void*)NULL,85,0,0,G__get_linked_tagnum(&G__G__Geom1LN_TObjArray),-1,-1,4,"fMatrices=",0,"-> list of local transformations");
   G__memvar_setup((void*)NULL,85,0,0,G__get_linked_tagnum(&G__G__Geom1LN_TObjArray),-1,-1,4,"fShapes=",0,"-> list of shapes");
   G__memvar_setup((void*)NULL,85,0,0,G__get_linked_tagnum(&G__G__Geom1LN_TObjArray),-1,-1,4,"fVolumes=",0,"-> list of volumes");
   G__memvar_setup((void*)NULL,85,0,0,G__get_linked_tagnum(&G__G__Geom1LN_TObjArray),-1,-1,4,"fPhysicalNodes=",0,"-> list of physical nodes");
   G__memvar_setup((void*)NULL,85,0,0,G__get_linked_tagnum(&G__G__Geom1LN_TObjArray),-1,-1,4,"fGShapes=",0,"! list of runtime shapes");
   G__memvar_setup((void*)NULL,85,0,0,G__get_linked_tagnum(&G__G__Geom1LN_TObjArray),-1,-1,4,"fGVolumes=",0,"! list of runtime volumes");
   G__memvar_setup((void*)NULL,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*)NULL,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*)NULL,85,0,0,G__get_linked_tagnum(&G__G__Geom1LN_TList),-1,-1,4,"fMaterials=",0,"-> list of materials");
   G__memvar_setup((void*)NULL,85,0,0,G__get_linked_tagnum(&G__G__Geom1LN_TList),-1,-1,4,"fMedia=",0,"-> list of tracking media");
   G__memvar_setup((void*)NULL,85,0,0,G__get_linked_tagnum(&G__G__Geom1LN_TObjArray),-1,-1,4,"fNodes=",0,"-> current branch of nodes");
   G__memvar_setup((void*)NULL,85,0,0,G__get_linked_tagnum(&G__G__Geom1LN_TObjArray),-1,-1,4,"fOverlaps=",0,"-> list of geometrical overlaps");
   G__memvar_setup((void*)NULL,66,0,0,-1,G__defined_typename("UChar_t"),-1,4,"fBits=",0,"! bits used for voxelization");
   G__memvar_setup((void*)NULL,85,0,0,G__get_linked_tagnum(&G__G__Geom1LN_TGeoVolume),-1,-1,4,"fCurrentVolume=",0,"! current volume");
   G__memvar_setup((void*)NULL,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*)NULL,85,0,0,G__get_linked_tagnum(&G__G__Geom1LN_TGeoNode),-1,-1,4,"fCurrentNode=",0,"! current node");
   G__memvar_setup((void*)NULL,85,0,0,G__get_linked_tagnum(&G__G__Geom1LN_TGeoNode),-1,-1,4,"fTopNode=",0,"! top physical node");
   G__memvar_setup((void*)NULL,85,0,0,G__get_linked_tagnum(&G__G__Geom1LN_TGeoNode),-1,-1,4,"fLastNode=",0,"! last searched node");
   G__memvar_setup((void*)NULL,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*)NULL,85,0,0,G__get_linked_tagnum(&G__G__Geom1LN_TGeoVolume),-1,-1,4,"fMasterVolume=",0,"master volume");
   G__memvar_setup((void*)NULL,85,0,0,G__get_linked_tagnum(&G__G__Geom1LN_TGeoHMatrix),-1,-1,4,"fCurrentMatrix=",0,"! current global matrix");
   G__memvar_setup((void*)NULL,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*)NULL,85,0,0,G__get_linked_tagnum(&G__G__Geom1LN_TObjArray),-1,-1,4,"fUniqueVolumes=",0,"-> list of unique volumes");
   G__memvar_setup((void*)NULL,85,0,0,G__get_linked_tagnum(&G__G__Geom1LN_TGeoShape),-1,-1,4,"fClippingShape=",0,"! clipping shape for raytracing");
   G__memvar_setup((void*)NULL,85,0,0,G__get_linked_tagnum(&G__G__Geom1LN_TGeoElementTable),-1,-1,4,"fElementTable=",0,"! table of elements");
   G__memvar_setup((void*)NULL,73,0,0,-1,G__defined_typename("Int_t"),-1,4,"fNodeIdArray=",0,"! array of node id's");
   G__memvar_setup((void*)NULL,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fIntSize=",0,"! int buffer size");
   G__memvar_setup((void*)NULL,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fDblSize=",0,"! dbl buffer size");
   G__memvar_setup((void*)NULL,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fOverlapSize=",0,"! current size of fOverlapClusters");
   G__memvar_setup((void*)NULL,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fOverlapMark=",0,"! current recursive position in fOverlapClusters");
   G__memvar_setup((void*)NULL,73,0,0,-1,G__defined_typename("Int_t"),-1,4,"fIntBuffer=",0,"! transient int buffer");
   G__memvar_setup((void*)NULL,73,0,0,-1,G__defined_typename("Int_t"),-1,4,"fOverlapClusters=",0,"! internal array for overlaps");
   G__memvar_setup((void*)NULL,68,0,0,-1,G__defined_typename("Double_t"),-1,4,"fDblBuffer=",0,"! transient dbl buffer");
   G__memvar_setup((void*)NULL,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*)NULL,85,0,0,G__get_linked_tagnum(&G__G__Geom1LN_TGeoVolume),-1,-1,4,"fPaintVolume=",0,"! volume currently painted");
   G__memvar_setup((void*)NULL,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*)NULL,85,0,0,G__get_linked_tagnum(&G__G__Geom1LN_TObjArray),-1,-1,4,"fVolumes=",0,"list of volumes");
   G__memvar_setup((void*)NULL,85,0,0,G__get_linked_tagnum(&G__G__Geom1LN_TGeoVolumeMulti),-1,-1,4,"fDivision=",0,"division of this volume");
   G__memvar_setup((void*)NULL,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fNumed=",0,"medium number for divisions");
   G__memvar_setup((void*)NULL,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fNdiv=",0,"number of divisions");
   G__memvar_setup((void*)NULL,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fAxis=",0,"axis of division");
   G__memvar_setup((void*)NULL,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fStart=",0,"division start offset");
   G__memvar_setup((void*)NULL,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fStep=",0,"division step");
   G__memvar_setup((void*)NULL,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fAttSet=",0,"flag attributes set");
   G__memvar_setup((void*)NULL,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*)NULL,85,0,0,G__get_linked_tagnum(&G__G__Geom1LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGeoCylVoxels */
static void G__setup_memvarTGeoCylVoxels(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoCylVoxels));
   { TGeoCylVoxels *p; p=(TGeoCylVoxels*)0x1000; if (p) { }
   G__memvar_setup((void*)NULL,85,0,0,G__get_linked_tagnum(&G__G__Geom1LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGeoFullVoxels */
static void G__setup_memvarTGeoFullVoxels(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoFullVoxels));
   { TGeoFullVoxels *p; p=(TGeoFullVoxels*)0x1000; if (p) { }
   G__memvar_setup((void*)NULL,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fNvoxels=",0,(char*)NULL);
   G__memvar_setup((void*)NULL,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fNvx=",0,"number of slices on X");
   G__memvar_setup((void*)NULL,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fNvy=",0,"number of slices on Y");
   G__memvar_setup((void*)NULL,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fNvz=",0,"number of slices on Z");
   G__memvar_setup((void*)NULL,66,0,0,-1,G__defined_typename("UChar_t"),-1,4,"fVox=",0,"[fNvoxels] voxels storage array");
   G__memvar_setup((void*)NULL,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*)NULL,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*)NULL,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*)NULL,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*)NULL,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fIndex=",0,"index of this node in the division");
   G__memvar_setup((void*)NULL,85,0,0,G__get_linked_tagnum(&G__G__Geom1LN_TGeoPatternFinder),-1,-1,4,"fFinder=",0,"finder for this node");
   G__memvar_setup((void*)NULL,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*)NULL,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fX=",0,"X half-length");
   G__memvar_setup((void*)NULL,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fY=",0,"Y half-length");
   G__memvar_setup((void*)NULL,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fZ=",0,"Z half-length");
   G__memvar_setup((void*)NULL,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*)NULL,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*)NULL,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*)NULL,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fTxy=",0,"tangent of XY section angle");
   G__memvar_setup((void*)NULL,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fTxz=",0,"tangent of XZ section angle");
   G__memvar_setup((void*)NULL,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fTyz=",0,"tangent of XZ section angle");
   G__memvar_setup((void*)NULL,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*)NULL,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fRmin=",0,"inner radius");
   G__memvar_setup((void*)NULL,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fRmax=",0,"outer radius");
   G__memvar_setup((void*)NULL,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fDz=",0,"half length");
   G__memvar_setup((void*)NULL,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*)NULL,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fPhi1=",0,"first phi limit ");
   G__memvar_setup((void*)NULL,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fPhi2=",0,"second phi limit ");
   G__memvar_setup((void*)NULL,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*)NULL,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fNlow[3]=",0,"normal to lower cut plane ");
   G__memvar_setup((void*)NULL,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fNhigh[3]=",0,"normal to highet cut plane ");
   G__memvar_setup((void*)NULL,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*)NULL,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fR=",0,"axial radius");
   G__memvar_setup((void*)NULL,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fRmin=",0,"inner radius");
   G__memvar_setup((void*)NULL,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fRmax=",0,"outer radius");
   G__memvar_setup((void*)NULL,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fPhi1=",0,"starting phi");
   G__memvar_setup((void*)NULL,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fDphi=",0,"phi extent");
   G__memvar_setup((void*)NULL,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*)NULL,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fNz=",0,"number of z planes for drawing");
   G__memvar_setup((void*)NULL,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fNseg=",0,"number of segments for drawing");
   G__memvar_setup((void*)NULL,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fRmin=",0,"inner radius");
   G__memvar_setup((void*)NULL,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fRmax=",0,"outer radius");
   G__memvar_setup((void*)NULL,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fTheta1=",0,"lower theta limit");
   G__memvar_setup((void*)NULL,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fTheta2=",0,"higher theta limit");
   G__memvar_setup((void*)NULL,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fPhi1=",0,"lower phi limit");
   G__memvar_setup((void*)NULL,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fPhi2=",0,"higher phi limit");
   G__memvar_setup((void*)NULL,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*)NULL,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*)NULL,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fStIn=",0,"Stereo angle for inner surface");
   G__memvar_setup((void*)NULL,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fStOut=",0,"Stereo angle for inner surface");
   G__memvar_setup((void*)NULL,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fTin=",0,"Tangent of stereo angle for inner surface");
   G__memvar_setup((void*)NULL,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fTout=",0,"Tangent of stereo angle for outer surface");
   G__memvar_setup((void*)NULL,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*)NULL,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*)NULL,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*)NULL,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fDz=",0,"half length");
   G__memvar_setup((void*)NULL,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fRmin1=",0,"inner radius at -dz");
   G__memvar_setup((void*)NULL,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fRmax1=",0,"outer radius at -dz");
   G__memvar_setup((void*)NULL,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fRmin2=",0,"inner radius at +dz");
   G__memvar_setup((void*)NULL,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fRmax2=",0,"outer radius at +dz");
   G__memvar_setup((void*)NULL,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*)NULL,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fPhi1=",0,"first phi limit ");
   G__memvar_setup((void*)NULL,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fPhi2=",0,"second phi limit ");
   G__memvar_setup((void*)NULL,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*)NULL,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fNz=",0,"number of z planes (at least two)");
   G__memvar_setup((void*)NULL,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fPhi1=",0,"lower phi limit ");
   G__memvar_setup((void*)NULL,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fDphi=",0,"phi range");
   G__memvar_setup((void*)NULL,68,0,0,-1,G__defined_typename("Double_t"),-1,2,"fRmin=",0,"[fNz] pointer to array of inner radii ");
   G__memvar_setup((void*)NULL,68,0,0,-1,G__defined_typename("Double_t"),-1,2,"fRmax=",0,"[fNz] pointer to array of outer radii ");
   G__memvar_setup((void*)NULL,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*)NULL,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*)NULL,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fNedges=",0,"number of edges (at least one)");
   G__memvar_setup((void*)NULL,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,1,"kArb8Trap=134217728",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Geom1LN_TGeoArb8cLcLEGeoArb8Type),-1,-2,1,"kArb8Tra=268435456",0,(char*)NULL);
   G__memvar_setup((void*)NULL,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fDz=",0,"half length in Z");
   G__memvar_setup((void*)NULL,68,0,0,-1,G__defined_typename("Double_t"),-1,2,"fTwist=",0,"! [4] tangents of twist angles ");
   G__memvar_setup((void*)NULL,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fXY[8][2]=",0,"list of vertices");
   G__memvar_setup((void*)NULL,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*)NULL,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fTheta=",0,"theta angle");
   G__memvar_setup((void*)NULL,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fPhi=",0,"phi angle");
   G__memvar_setup((void*)NULL,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fH1=",0,"half length in y at low z");
   G__memvar_setup((void*)NULL,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*)NULL,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*)NULL,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*)NULL,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fH2=",0,"half length in y at high z");
   G__memvar_setup((void*)NULL,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*)NULL,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*)NULL,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*)NULL,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*)NULL,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fTwistAngle=",0,"twist angle in degrees");
   G__memvar_setup((void*)NULL,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*)NULL,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*)NULL,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*)NULL,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fDy=",0,"half length in Y");
   G__memvar_setup((void*)NULL,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fDz=",0,"half length in Z");
   G__memvar_setup((void*)NULL,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*)NULL,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*)NULL,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*)NULL,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*)NULL,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*)NULL,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fDz=",0,"half length in Z");
   G__memvar_setup((void*)NULL,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*)NULL,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fPDG=",0,"track pdg code");
   G__memvar_setup((void*)NULL,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fId=",0,"track id");
   G__memvar_setup((void*)NULL,85,0,0,G__get_linked_tagnum(&G__G__Geom1LN_TVirtualGeoTrack),-1,-1,2,"fParent=",0,"id of parent");
   G__memvar_setup((void*)NULL,85,0,0,G__get_linked_tagnum(&G__G__Geom1LN_TObject),-1,-1,2,"fParticle=",0,"particle for this track");
   G__memvar_setup((void*)NULL,85,0,0,G__get_linked_tagnum(&G__G__Geom1LN_TObjArray),-1,-1,2,"fTracks=",0,"daughter tracks");
   G__memvar_setup((void*)NULL,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*)NULL,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fLevel=",0,"depth in the geometry tree");
   G__memvar_setup((void*)NULL,85,0,0,G__get_linked_tagnum(&G__G__Geom1LN_TObjArray),-1,-1,2,"fMatrices=",0,"global transformation matrices");
   G__memvar_setup((void*)NULL,85,0,0,G__get_linked_tagnum(&G__G__Geom1LN_TObjArray),-1,-1,2,"fNodes=",0,"branch of nodes");
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Geom1LN_TGeoPhysicalNodecLcLdA),-1,-2,1,"kGeoPNodeFull=1024",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Geom1LN_TGeoPhysicalNodecLcLdA),-1,-2,1,"kGeoPNodeVisible=2048",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Geom1LN_TGeoPhysicalNodecLcLdA),-1,-2,1,"kGeoPNodeVolAtt=4096",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Geom1LN_TGeoPhysicalNodecLcLdA),-1,-2,1,"kGeoPNodeAligned=8192",0,(char*)NULL);
   G__memvar_setup((void*)NULL,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*)NULL,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,"kGeoVisLevel=0",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Geom1LN_TVirtualGeoPaintercLcLEGeoVisOption),-1,-2,1,"kGeoVisDefault=0",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Geom1LN_TVirtualGeoPaintercLcLEGeoVisOption),-1,-2,1,"kGeoVisLeaves=1",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Geom1LN_TVirtualGeoPaintercLcLEGeoVisOption),-1,-2,1,"kGeoVisOnly=2",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Geom1LN_TVirtualGeoPaintercLcLEGeoVisOption),-1,-2,1,"kGeoVisBranch=3",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Geom1LN_TVirtualGeoPaintercLcLEGeoBombOption),-1,-2,1,"kGeoNoBomb=0",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Geom1LN_TVirtualGeoPaintercLcLEGeoBombOption),-1,-2,1,"kGeoBombXYZ=1",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Geom1LN_TVirtualGeoPaintercLcLEGeoBombOption),-1,-2,1,"kGeoBombCyl=2",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Geom1LN_TVirtualGeoPaintercLcLEGeoBombOption),-1,-2,1,"kGeoBombSph=3",0,(char*)NULL);
   G__memvar_setup((void*)NULL,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*)NULL,85,0,0,G__get_linked_tagnum(&G__G__Geom1LN_TGeoBoolNode),-1,-1,4,"fNode=",0,"top boolean node");
   G__memvar_setup((void*)NULL,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,"kGeoConvex=512",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Geom1LN_TGeoPolygoncLcLdA),-1,-2,1,"kGeoFinishPolygon=1024",0,(char*)NULL);
   G__memvar_setup((void*)NULL,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*)NULL,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*)NULL,73,0,0,-1,G__defined_typename("Int_t"),-1,2,"fInd=",0,"[fNvert] list of vertex indices");
   G__memvar_setup((void*)NULL,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*)NULL,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*)NULL,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*)NULL,85,0,0,G__get_linked_tagnum(&G__G__Geom1LN_TObjArray),-1,-1,2,"fDaughters=",0,"list of concave daughters");
   G__memvar_setup((void*)NULL,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*)NULL,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*)NULL,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fNz=",0,"number of z planes (at least two)");
   G__memvar_setup((void*)NULL,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fZcurrent=",0,"current Z position");
   G__memvar_setup((void*)NULL,85,0,0,G__get_linked_tagnum(&G__G__Geom1LN_TGeoPolygon),-1,-1,2,"fPoly=",0,"polygon defining section shape");
   G__memvar_setup((void*)NULL,68,0,0,-1,G__defined_typename("Double_t"),-1,2,"fX=",0,"[fNvert] X positions for polygon vertices");
   G__memvar_setup((void*)NULL,68,0,0,-1,G__defined_typename("Double_t"),-1,2,"fY=",0,"[fNvert] Y positions for polygon vertices");
   G__memvar_setup((void*)NULL,68,0,0,-1,G__defined_typename("Double_t"),-1,2,"fXc=",0,"[fNvert] current X positions for polygon vertices");
   G__memvar_setup((void*)NULL,68,0,0,-1,G__defined_typename("Double_t"),-1,2,"fYc=",0,"[fNvert] current Y positions for polygon vertices");
   G__memvar_setup((void*)NULL,68,0,0,-1,G__defined_typename("Double_t"),-1,2,"fZ=",0,"[fNz] array of Z planes positions ");
   G__memvar_setup((void*)NULL,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*)NULL,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*)NULL,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*)NULL,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fSeg=",0,"!current segment [0,fNvert-1]");
   G__memvar_setup((void*)NULL,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fIz=",0,"!current z plane [0,fNz-1]");
   G__memvar_setup((void*)NULL,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*)NULL,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fC=",0,"curvature in XY plane");
   G__memvar_setup((void*)NULL,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fS=",0,"Z step of the helix / 2*PI");
   G__memvar_setup((void*)NULL,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fStep=",0,"current step");
   G__memvar_setup((void*)NULL,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fPhi=",0,"phi angle");
   G__memvar_setup((void*)NULL,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fPointInit[3]=",0,"initial point");
   G__memvar_setup((void*)NULL,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fDirInit[3]=",0,"normalized initial direction");
   G__memvar_setup((void*)NULL,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fPoint[3]=",0,"point after a step");
   G__memvar_setup((void*)NULL,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fDir[3]=",0,"direction after a step");
   G__memvar_setup((void*)NULL,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fB[3]=",0,"normalized direction for magnetic field");
   G__memvar_setup((void*)NULL,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fQ=",0,"right/left-handed (+/- 1) - \"charge\"");
   G__memvar_setup((void*)NULL,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,"kHelixNeedUpdate=65536",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Geom1LN_TGeoHelixcLcLEGeoHelixTypes),-1,-2,1,"kHelixStraigth=131072",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Geom1LN_TGeoHelixcLcLEGeoHelixTypes),-1,-2,1,"kHelixCircle=262144",0,(char*)NULL);
   G__memvar_setup((void*)NULL,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*)NULL,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fRlo=",0,"radius at z=-dz");
   G__memvar_setup((void*)NULL,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fRhi=",0,"radius at z=+dz");
   G__memvar_setup((void*)NULL,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fDz=",0,"range on Z axis [-dz, dz]");
   G__memvar_setup((void*)NULL,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fA=",0,"quadratic coeff.");
   G__memvar_setup((void*)NULL,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*)NULL,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*)NULL,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fP[3]=",0,(char*)NULL);
   G__memvar_setup((void*)NULL,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fN[3]=",0,(char*)NULL);
   G__memvar_setup((void*)NULL,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_131_1_0,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_131_2_0,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_131_3_0,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_131_4_0,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_131_5_0,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_131_6_0,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("SetVisibility",1364,G__G__Geom1_131_7_0,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_131_8_0,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_131_9_0,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_131_0_1,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_131_1_1,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_131_2_1,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_131_3_1,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_131_4_1,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_131_5_1,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_131_6_1,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_131_7_1,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_131_8_1,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_131_9_1,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_131_0_2,85,G__get_linked_tagnum(&G__G__Geom1LN_TClass),-1,0,0,3,1,0,"",(char*)NULL,(void*)(TClass* (*)())(&TGeoAtt::Class),0);
   G__memfunc_setup("Class_Name",982,G__G__Geom1_131_1_2,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)(const char* (*)())(&TGeoAtt::Class_Name),0);
   G__memfunc_setup("Class_Version",1339,G__G__Geom1_131_2_2,115,-1,G__defined_typename("Version_t"),0,0,3,1,0,"",(char*)NULL,(void*)(Version_t (*)())(&TGeoAtt::Class_Version),0);
   G__memfunc_setup("Dictionary",1046,G__G__Geom1_131_3_2,121,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)(void (*)())(&TGeoAtt::Dictionary),0);
   G__memfunc_setup("IsA",253,G__G__Geom1_131_4_2,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_131_5_2,121,-1,-1,0,2,1,1,0,
"u 'TMemberInspector' - 1 - insp C - - 0 - parent",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("Streamer",835,G__G__Geom1_131_6_2,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_131_7_2,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_131_8_2,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)(const char* (*)())(&TGeoAtt::DeclFileName),0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Geom1_131_9_2,105,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)(int (*)())(&TGeoAtt::ImplFileLine),0);
   G__memfunc_setup("ImplFileName",1171,G__G__Geom1_131_0_3,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)(const char* (*)())(&TGeoAtt::ImplFileName),0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Geom1_131_1_3,105,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)(int (*)())(&TGeoAtt::DeclFileLine),0);
   // automatic copy constructor
   G__memfunc_setup("TGeoAtt",664,G__G__Geom1_131_2_3,(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_131_3_3,(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_131_4_3,(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_137_7_0,100,-1,G__defined_typename("Double_t"),0,0,3,1,0,"",(char*)NULL,(void*)(Double_t (*)())(&TGeoShape::Big),0);
   G__memfunc_setup("Tolerance",925,G__G__Geom1_137_8_0,100,-1,G__defined_typename("Double_t"),0,0,3,1,0,"",(char*)NULL,(void*)(Double_t (*)())(&TGeoShape::Tolerance),0);
   G__memfunc_setup("ComputeBBox",1096,G__G__Geom1_137_9_0,121,-1,-1,0,0,1,1,0,"",(char*)NULL,(void*)NULL,3);
   G__memfunc_setup("ComputeNormal",1350,G__G__Geom1_137_0_1,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_137_1_1,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_137_2_1,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__G__Geom1_137_3_1,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_137_4_1,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_137_5_1,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_137_6_1,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*)(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_137_7_1,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("GetAxisName",1078,G__G__Geom1_137_8_1,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_137_9_1,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_137_0_2,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_137_1_2,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_137_2_2,105,-1,G__defined_typename("Int_t"),0,0,1,1,8,"",(char*)NULL,(void*)NULL,3);
   G__memfunc_setup("GetFittingBox",1310,G__G__Geom1_137_3_2,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_137_4_2,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_137_5_2,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("GetName",673,G__G__Geom1_137_6_2,67,-1,-1,0,0,1,1,9,"",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("GetNmeshVertices",1632,G__G__Geom1_137_7_2,105,-1,G__defined_typename("Int_t"),0,0,1,1,8,"",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("IsComposite",1135,G__G__Geom1_137_8_2,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_137_9_2,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_137_0_3,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*)(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_137_1_3,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*)(Bool_t (*)(Double_t*,Double_t*,Double_t,Double_t,Double_t&,Double_t&))(&TGeoShape::IsCrossingSemiplane),0);
   G__memfunc_setup("IsInPhiRange",1153,G__G__Geom1_137_2_3,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*)(Bool_t (*)(Double_t*,Double_t,Double_t))(&TGeoShape::IsInPhiRange),0);
   G__memfunc_setup("IsRunTimeShape",1393,G__G__Geom1_137_3_3,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_137_4_3,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_137_5_3,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_137_6_3,121,-1,-1,0,0,1,1,8,"",(char*)NULL,(void*)NULL,3);
   G__memfunc_setup("MakeBuffer3D",1103,G__G__Geom1_137_7_3,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_137_8_3,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*)(void (*)(Double_t*,Double_t*,Double_t*,Double_t,Double_t,Double_t,Double_t))(&TGeoShape::NormalPhi),0);
   G__memfunc_setup("Safety",620,G__G__Geom1_137_9_3,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_137_0_4,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*)(Double_t (*)(Double_t*,Bool_t,Double_t,Double_t))(&TGeoShape::SafetyPhi),0);
   G__memfunc_setup("SetDimensions",1349,G__G__Geom1_137_1_4,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_137_2_4,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_137_3_4,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_137_4_4,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_137_5_4,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_137_6_4,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_137_7_4,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_137_8_4,121,-1,-1,0,0,1,1,8,"",(char*)NULL,(void*)NULL,3);
   G__memfunc_setup("SetShapeBit",1084,G__G__Geom1_137_9_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("SetShapeBit",1084,G__G__Geom1_137_0_5,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_137_1_5,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_137_2_5,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_137_3_5,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_137_4_5,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_137_5_5,85,G__get_linked_tagnum(&G__G__Geom1LN_TClass),-1,0,0,3,1,0,"",(char*)NULL,(void*)(TClass* (*)())(&TGeoShape::Class),0);
   G__memfunc_setup("Class_Name",982,G__G__Geom1_137_6_5,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)(const char* (*)())(&TGeoShape::Class_Name),0);
   G__memfunc_setup("Class_Version",1339,G__G__Geom1_137_7_5,115,-1,G__defined_typename("Version_t"),0,0,3,1,0,"",(char*)NULL,(void*)(Version_t (*)())(&TGeoShape::Class_Version),0);
   G__memfunc_setup("Dictionary",1046,G__G__Geom1_137_8_5,121,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)(void (*)())(&TGeoShape::Dictionary),0);
   G__memfunc_setup("IsA",253,G__G__Geom1_137_9_5,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_137_0_6,121,-1,-1,0,2,1,1,0,
"u 'TMemberInspector' - 1 - insp C - - 0 - parent",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("Streamer",835,G__G__Geom1_137_1_6,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_2_6,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_3_6,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)(const char* (*)())(&TGeoShape::DeclFileName),0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Geom1_137_4_6,105,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)(int (*)())(&TGeoShape::ImplFileLine),0);
   G__memfunc_setup("ImplFileName",1171,G__G__Geom1_137_5_6,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)(const char* (*)())(&TGeoShape::ImplFileName),0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Geom1_137_6_6,105,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)(int (*)())(&TGeoShape::DeclFileLine),0);
   // automatic destructor
   G__memfunc_setup("~TGeoShape",990,G__G__Geom1_137_7_6,(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_137_8_6,(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_138_4_0,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_138_5_0,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_138_6_0,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_138_7_0,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_138_8_0,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_138_9_0,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_138_0_1,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_138_1_1,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_138_2_1,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_138_3_1,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_138_4_1,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_138_5_1,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_138_6_1,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_138_7_1,67,-1,-1,0,0,1,1,8,"",(char*)NULL,(void*)NULL,0);
   G__memfunc_setup("GetByteCount",1213,G__G__Geom1_138_8_1,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_138_9_1,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_138_0_2,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_138_1_2,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_138_2_2,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_138_3_2,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_138_4_2,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_138_5_2,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("MasterToLocal",1306,G__G__Geom1_138_6_2,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_138_7_2,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_138_8_2,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("Print",525,G__G__Geom1_138_9_2,121,-1,-1,0,1,1,1,8,"C - 'Option_t' 10 \"\" option",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("RotateX",711,G__G__Geom1_138_0_3,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_138_1_3,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_138_2_3,121,-1,-1,0,1,1,1,0,"d - 'Double_t' 0 - -",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("RegisterYourself",1694,G__G__Geom1_138_3_3,121,-1,-1,0,0,1,1,0,"",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("SetDefaultName",1394,G__G__Geom1_138_4_3,121,-1,-1,0,0,1,1,0,"",(char*)NULL,(void*)NULL,0);
   G__memfunc_setup("Class",502,G__G__Geom1_138_5_3,85,G__get_linked_tagnum(&G__G__Geom1LN_TClass),-1,0,0,3,1,0,"",(char*)NULL,(void*)(TClass* (*)())(&TGeoMatrix::Class),0);
   G__memfunc_setup("Class_Name",982,G__G__Geom1_138_6_3,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)(const char* (*)())(&TGeoMatrix::Class_Name),0);
   G__memfunc_setup("Class_Version",1339,G__G__Geom1_138_7_3,115,-1,G__defined_typename("Version_t"),0,0,3,1,0,"",(char*)NULL,(void*)(Version_t (*)())(&TGeoMatrix::Class_Version),0);
   G__memfunc_setup("Dictionary",1046,G__G__Geom1_138_8_3,121,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)(void (*)())(&TGeoMatrix::Dictionary),0);
   G__memfunc_setup("IsA",253,G__G__Geom1_138_9_3,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_138_0_4,121,-1,-1,0,2,1,1,0,
"u 'TMemberInspector' - 1 - insp C - - 0 - parent",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("Streamer",835,G__G__Geom1_138_1_4,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_2_4,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_3_4,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)(const char* (*)())(&TGeoMatrix::DeclFileName),0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Geom1_138_4_4,105,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)(int (*)())(&TGeoMatrix::ImplFileLine),0);
   G__memfunc_setup("ImplFileName",1171,G__G__Geom1_138_5_4,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)(const char* (*)())(&TGeoMatrix::ImplFileName),0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Geom1_138_6_4,105,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)(int (*)())(&TGeoMatrix::DeclFileLine),0);
   // automatic destructor
   G__memfunc_setup("~TGeoMatrix",1122,G__G__Geom1_138_7_4,(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_139_1_0,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_139_2_0,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_139_3_0,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_139_4_0,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_139_5_0,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_139_6_0,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_139_7_0,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__G__Geom1_139_8_0,121,-1,-1,0,1,1,1,0,"C - 'Option_t' 10 \"\" option",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("Inverse",732,G__G__Geom1_139_9_0,117,G__get_linked_tagnum(&G__G__Geom1LN_TGeoMatrix),-1,1,0,1,1,8,"",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("Multiply",864,G__G__Geom1_139_0_1,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_139_1_1,121,-1,-1,0,1,1,1,0,"U 'TGeoMatrix' - 10 - left",(char*)NULL,(void*)NULL,0);
   G__memfunc_setup("RotateX",711,G__G__Geom1_139_2_1,121,-1,-1,0,1,1,1,0,"d - 'Double_t' 0 - angle",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("RotateY",712,G__G__Geom1_139_3_1,121,-1,-1,0,1,1,1,0,"d - 'Double_t' 0 - angle",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("RotateZ",713,G__G__Geom1_139_4_1,121,-1,-1,0,1,1,1,0,"d - 'Double_t' 0 - angle",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("SavePrimitive",1352,G__G__Geom1_139_5_1,121,-1,-1,0,2,1,1,0,
"u 'basic_ofstream<char,char_traits<char> >' 'ofstream' 1 - out C - 'Option_t' 10 - option",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("SetTranslation",1467,G__G__Geom1_139_6_1,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_139_7_1,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_139_8_1,121,-1,-1,0,1,1,1,0,"D - 'Double_t' 10 - scale",(char*)NULL,(void*)NULL,0);
   G__memfunc_setup("GetTranslation",1455,G__G__Geom1_139_9_1,68,-1,G__defined_typename("Double_t"),0,0,1,1,9,"",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("GetRotationMatrix",1765,G__G__Geom1_139_0_2,68,-1,G__defined_typename("Double_t"),0,0,1,1,9,"",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("GetScale",776,G__G__Geom1_139_1_2,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_139_2_2,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_139_3_2,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_139_4_2,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_139_5_2,85,G__get_linked_tagnum(&G__G__Geom1LN_TClass),-1,0,0,3,1,0,"",(char*)NULL,(void*)(TClass* (*)())(&TGeoHMatrix::Class),0);
   G__memfunc_setup("Class_Name",982,G__G__Geom1_139_6_2,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)(const char* (*)())(&TGeoHMatrix::Class_Name),0);
   G__memfunc_setup("Class_Version",1339,G__G__Geom1_139_7_2,115,-1,G__defined_typename("Version_t"),0,0,3,1,0,"",(char*)NULL,(void*)(Version_t (*)())(&TGeoHMatrix::Class_Version),0);
   G__memfunc_setup("Dictionary",1046,G__G__Geom1_139_8_2,121,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)(void (*)())(&TGeoHMatrix::Dictionary),0);
   G__memfunc_setup("IsA",253,G__G__Geom1_139_9_2,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_139_0_3,121,-1,-1,0,2,1,1,0,
"u 'TMemberInspector' - 1 - insp C - - 0 - parent",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("Streamer",835,G__G__Geom1_139_1_3,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_2_3,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_3_3,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)(const char* (*)())(&TGeoHMatrix::DeclFileName),0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Geom1_139_4_3,105,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)(int (*)())(&TGeoHMatrix::ImplFileLine),0);
   G__memfunc_setup("ImplFileName",1171,G__G__Geom1_139_5_3,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)(const char* (*)())(&TGeoHMatrix::ImplFileName),0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Geom1_139_6_3,105,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)(int (*)())(&TGeoHMatrix::DeclFileLine),0);
   // automatic copy constructor
   G__memfunc_setup("TGeoHMatrix",1068,G__G__Geom1_139_7_3,(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_139_8_3,(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("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_140_5_0,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_140_6_0,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_140_7_0,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_140_8_0,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_140_9_0,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_140_0_1,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_140_1_1,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_140_2_1,105,-1,G__defined_typename("Int_t"),0,0,1,1,8,"",(char*)NULL,(void*)NULL,3);
   G__memfunc_setup("GetLeftMatrix",1312,G__G__Geom1_140_3_1,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_140_4_1,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_140_5_1,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_140_6_1,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__G__Geom1_140_7_1,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_140_8_1,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("SetPoints",937,G__G__Geom1_140_9_1,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_140_0_2,121,-1,-1,0,1,1,1,8,"F - 'Float_t' 0 - points",(char*)NULL,(void*)NULL,3);
   G__memfunc_setup("SetSelected",1109,G__G__Geom1_140_1_2,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_140_2_2,121,-1,-1,0,0,1,1,8,"",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("Class",502,G__G__Geom1_140_3_2,85,G__get_linked_tagnum(&G__G__Geom1LN_TClass),-1,0,0,3,1,0,"",(char*)NULL,(void*)(TClass* (*)())(&TGeoBoolNode::Class),0);
   G__memfunc_setup("Class_Name",982,G__G__Geom1_140_4_2,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)(const char* (*)())(&TGeoBoolNode::Class_Name),0);
   G__memfunc_setup("Class_Version",1339,G__G__Geom1_140_5_2,115,-1,G__defined_typename("Version_t"),0,0,3,1,0,"",(char*)NULL,(void*)(Version_t (*)())(&TGeoBoolNode::Class_Version),0);
   G__memfunc_setup("Dictionary",1046,G__G__Geom1_140_6_2,121,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)(void (*)())(&TGeoBoolNode::Dictionary),0);
   G__memfunc_setup("IsA",253,G__G__Geom1_140_7_2,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_140_8_2,121,-1,-1,0,2,1,1,0,
"u 'TMemberInspector' - 1 - insp C - - 0 - parent",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("Streamer",835,G__G__Geom1_140_9_2,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_140_0_3,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_140_1_3,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)(const char* (*)())(&TGeoBoolNode::DeclFileName),0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Geom1_140_2_3,105,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)(int (*)())(&TGeoBoolNode::ImplFileLine),0);
   G__memfunc_setup("ImplFileName",1171,G__G__Geom1_140_3_3,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)(const char* (*)())(&TGeoBoolNode::ImplFileName),0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Geom1_140_4_3,105,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)(int (*)())(&TGeoBoolNode::DeclFileLine),0);
   // automatic destructor
   G__memfunc_setup("~TGeoBoolNode",1279,G__G__Geom1_140_5_3,(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_140_6_3,(int)('u'),G__get_linked_tagnum(&G__G__Geom1LN_TGeoBoolNode),-1,1,1,1,1,0,"u 'TGeoBoolNode' - 11 - -",(char*)NULL,(void*)NULL,0);
   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_142_1_0,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_142_2_0,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_142_3_0,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__G__Geom1_142_4_0,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__G__Geom1_142_5_0,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__G__Geom1_142_6_0,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__G__Geom1_142_7_0,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__G__Geom1_142_8_0,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__G__Geom1_142_9_0,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__G__Geom1_142_0_1,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__G__Geom1_142_1_1,105,-1,G__defined_typename("Int_t"),0,0,1,1,8,"",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("Safety",620,G__G__Geom1_142_2_1,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("SetPoints",937,G__G__Geom1_142_3_1,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_142_4_1,121,-1,-1,0,1,1,1,8,"F - 'Float_t' 0 - points",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("Sizeof3D",743,G__G__Geom1_142_5_1,121,-1,-1,0,0,1,1,8,"",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("Paint",508,G__G__Geom1_142_6_1,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_142_7_1,85,G__get_linked_tagnum(&G__G__Geom1LN_TClass),-1,0,0,3,1,0,"",(char*)NULL,(void*)(TClass* (*)())(&TGeoUnion::Class),0);
   G__memfunc_setup("Class_Name",982,G__G__Geom1_142_8_1,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)(const char* (*)())(&TGeoUnion::Class_Name),0);
   G__memfunc_setup("Class_Version",1339,G__G__Geom1_142_9_1,115,-1,G__defined_typename("Version_t"),0,0,3,1,0,"",(char*)NULL,(void*)(Version_t (*)())(&TGeoUnion::Class_Version),0);
   G__memfunc_setup("Dictionary",1046,G__G__Geom1_142_0_2,121,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)(void (*)())(&TGeoUnion::Dictionary),0);
   G__memfunc_setup("IsA",253,G__G__Geom1_142_1_2,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_142_2_2,121,-1,-1,0,2,1,1,0,
"u 'TMemberInspector' - 1 - insp C - - 0 - parent",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("Streamer",835,G__G__Geom1_142_3_2,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_4_2,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_5_2,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)(const char* (*)())(&TGeoUnion::DeclFileName),0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Geom1_142_6_2,105,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)(int (*)())(&TGeoUnion::ImplFileLine),0);
   G__memfunc_setup("ImplFileName",1171,G__G__Geom1_142_7_2,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)(const char* (*)())(&TGeoUnion::ImplFileName),0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Geom1_142_8_2,105,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)(int (*)())(&TGeoUnion::DeclFileLine),0);
   // automatic copy constructor
   G__memfunc_setup("TGeoUnion",888,G__G__Geom1_142_9_2,(int)('i'),G__get_linked_tagnum(&G__G__Geom1LN_TGeoUnion),-1,0,1,1,1,0,"u 'TGeoUnion' - 11 - -",(char*)NULL,(void*)NULL,0);
   // automatic destructor
   G__memfunc_setup("~TGeoUnion",1014,G__G__Geom1_142_0_3,(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_142_1_3,(int)('u'),G__get_linked_tagnum(&G__G__Geom1LN_TGeoUnion),-1,1,1,1,1,0,"u 'TGeoUnion' - 11 - -",(char*)NULL,(void*)NULL,0);
   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_143_1_0,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_143_2_0,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_143_3_0,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__G__Geom1_143_4_0,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__G__Geom1_143_5_0,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__G__Geom1_143_6_0,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__G__Geom1_143_7_0,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__G__Geom1_143_8_0,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__G__Geom1_143_9_0,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__G__Geom1_143_0_1,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__G__Geom1_143_1_1,105,-1,G__defined_typename("Int_t"),0,0,1,1,8,"",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("Safety",620,G__G__Geom1_143_2_1,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("SetPoints",937,G__G__Geom1_143_3_1,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_143_4_1,121,-1,-1,0,1,1,1,8,"F - 'Float_t' 0 - points",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("Sizeof3D",743,G__G__Geom1_143_5_1,121,-1,-1,0,0,1,1,8,"",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("Paint",508,G__G__Geom1_143_6_1,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_143_7_1,85,G__get_linked_tagnum(&G__G__Geom1LN_TClass),-1,0,0,3,1,0,"",(char*)NULL,(void*)(TClass* (*)())(&TGeoIntersection::Class),0);
   G__memfunc_setup("Class_Name",982,G__G__Geom1_143_8_1,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)(const char* (*)())(&TGeoIntersection::Class_Name),0);
   G__memfunc_setup("Class_Version",1339,G__G__Geom1_143_9_1,115,-1,G__defined_typename("Version_t"),0,0,3,1,0,"",(char*)NULL,(void*)(Version_t (*)())(&TGeoIntersection::Class_Version),0);
   G__memfunc_setup("Dictionary",1046,G__G__Geom1_143_0_2,121,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)(void (*)())(&TGeoIntersection::Dictionary),0);
   G__memfunc_setup("IsA",253,G__G__Geom1_143_1_2,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_143_2_2,121,-1,-1,0,2,1,1,0,
"u 'TMemberInspector' - 1 - insp C - - 0 - parent",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("Streamer",835,G__G__Geom1_143_3_2,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_4_2,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_5_2,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)(const char* (*)())(&TGeoIntersection::DeclFileName),0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Geom1_143_6_2,105,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)(int (*)())(&TGeoIntersection::ImplFileLine),0);
   G__memfunc_setup("ImplFileName",1171,G__G__Geom1_143_7_2,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)(const char* (*)())(&TGeoIntersection::ImplFileName),0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Geom1_143_8_2,105,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)(int (*)())(&TGeoIntersection::DeclFileLine),0);
   // automatic copy constructor
   G__memfunc_setup("TGeoIntersection",1638,G__G__Geom1_143_9_2,(int)('i'),G__get_linked_tagnum(&G__G__Geom1LN_TGeoIntersection),-1,0,1,1,1,0,"u 'TGeoIntersection' - 11 - -",(char*)NULL,(void*)NULL,0);
   // automatic destructor
   G__memfunc_setup("~TGeoIntersection",1764,G__G__Geom1_143_0_3,(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_143_1_3,(int)('u'),G__get_linked_tagnum(&G__G__Geom1LN_TGeoIntersection),-1,1,1,1,1,0,"u 'TGeoIntersection' - 11 - -",(char*)NULL,(void*)NULL,0);
   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_144_1_0,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_144_2_0,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_144_3_0,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__G__Geom1_144_4_0,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__G__Geom1_144_5_0,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__G__Geom1_144_6_0,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__G__Geom1_144_7_0,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__G__Geom1_144_8_0,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__G__Geom1_144_9_0,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__G__Geom1_144_0_1,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__G__Geom1_144_1_1,105,-1,G__defined_typename("Int_t"),0,0,1,1,8,"",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("Safety",620,G__G__Geom1_144_2_1,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("SetPoints",937,G__G__Geom1_144_3_1,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_144_4_1,121,-1,-1,0,1,1,1,8,"F - 'Float_t' 0 - points",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("Sizeof3D",743,G__G__Geom1_144_5_1,121,-1,-1,0,0,1,1,8,"",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("Paint",508,G__G__Geom1_144_6_1,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_144_7_1,85,G__get_linked_tagnum(&G__G__Geom1LN_TClass),-1,0,0,3,1,0,"",(char*)NULL,(void*)(TClass* (*)())(&TGeoSubtraction::Class),0);
   G__memfunc_setup("Class_Name",982,G__G__Geom1_144_8_1,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)(const char* (*)())(&TGeoSubtraction::Class_Name),0);
   G__memfunc_setup("Class_Version",1339,G__G__Geom1_144_9_1,115,-1,G__defined_typename("Version_t"),0,0,3,1,0,"",(char*)NULL,(void*)(Version_t (*)())(&TGeoSubtraction::Class_Version),0);
   G__memfunc_setup("Dictionary",1046,G__G__Geom1_144_0_2,121,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)(void (*)())(&TGeoSubtraction::Dictionary),0);
   G__memfunc_setup("IsA",253,G__G__Geom1_144_1_2,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_144_2_2,121,-1,-1,0,2,1,1,0,
"u 'TMemberInspector' - 1 - insp C - - 0 - parent",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("Streamer",835,G__G__Geom1_144_3_2,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_144_4_2,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_144_5_2,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)(const char* (*)())(&TGeoSubtraction::DeclFileName),0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Geom1_144_6_2,105,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)(int (*)())(&TGeoSubtraction::ImplFileLine),0);
   G__memfunc_setup("ImplFileName",1171,G__G__Geom1_144_7_2,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)(const char* (*)())(&TGeoSubtraction::ImplFileName),0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Geom1_144_8_2,105,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)(int (*)())(&TGeoSubtraction::DeclFileLine),0);
   // automatic copy constructor
   G__memfunc_setup("TGeoSubtraction",1533,G__G__Geom1_144_9_2,(int)('i'),G__get_linked_tagnum(&G__G__Geom1LN_TGeoSubtraction),-1,0,1,1,1,0,"u 'TGeoSubtraction' - 11 - -",(char*)NULL,(void*)NULL,0);
   // automatic destructor
   G__memfunc_setup("~TGeoSubtraction",1659,G__G__Geom1_144_0_3,(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_144_1_3,(int)('u'),G__get_linked_tagnum(&G__G__Geom1LN_TGeoSubtraction),-1,1,1,1,1,0,"u 'TGeoSubtraction' - 11 - -",(char*)NULL,(void*)NULL,0);
   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("BuildDefaultElements",2034,(G__InterfaceMethod)NULL,121,-1,-1,0,0,1,4,0,"",(char*)NULL,(void*)NULL,0);
   G__memfunc_setup("TGeoElementTable",1569,G__G__Geom1_151_2_0,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_151_3_0,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_151_4_0,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("FindElement",1099,G__G__Geom1_151_5_0,85,G__get_linked_tagnum(&G__G__Geom1LN_TGeoElement),-1,0,1,1,1,0,"C - - 10 - name",(char*)NULL,(void*)NULL,0);
   G__memfunc_setup("GetElement",1002,G__G__Geom1_151_6_0,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("GetNelements",1227,G__G__Geom1_151_7_0,105,-1,G__defined_typename("Int_t"),0,0,1,1,8,"",(char*)NULL,(void*)NULL,0);
   G__memfunc_setup("Class",502,G__G__Geom1_151_8_0,85,G__get_linked_tagnum(&G__G__Geom1LN_TClass),-1,0,0,3,1,0,"",(char*)NULL,(void*)(TClass* (*)())(&TGeoElementTable::Class),0);
   G__memfunc_setup("Class_Name",982,G__G__Geom1_151_9_0,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)(const char* (*)())(&TGeoElementTable::Class_Name),0);
   G__memfunc_setup("Class_Version",1339,G__G__Geom1_151_0_1,115,-1,G__defined_typename("Version_t"),0,0,3,1,0,"",(char*)NULL,(void*)(Version_t (*)())(&TGeoElementTable::Class_Version),0);
   G__memfunc_setup("Dictionary",1046,G__G__Geom1_151_1_1,121,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)(void (*)())(&TGeoElementTable::Dictionary),0);
   G__memfunc_setup("IsA",253,G__G__Geom1_151_2_1,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_151_3_1,121,-1,-1,0,2,1,1,0,
"u 'TMemberInspector' - 1 - insp C - - 0 - parent",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("Streamer",835,G__G__Geom1_151_4_1,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_151_5_1,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_151_6_1,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)(const char* (*)())(&TGeoElementTable::DeclFileName),0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Geom1_151_7_1,105,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)(int (*)())(&TGeoElementTable::ImplFileLine),0);
   G__memfunc_setup("ImplFileName",1171,G__G__Geom1_151_8_1,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)(const char* (*)())(&TGeoElementTable::ImplFileName),0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Geom1_151_9_1,105,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)(int (*)())(&TGeoElementTable::DeclFileLine),0);
   // automatic copy constructor
   G__memfunc_setup("TGeoElementTable",1569,G__G__Geom1_151_0_2,(int)('i'),G__get_linked_tagnum(&G__G__Geom1LN_TGeoElementTable),-1,0,1,1,1,0,"u 'TGeoElementTable' - 11 - -",(char*)NULL,(void*)NULL,0);
   // automatic destructor
   G__memfunc_setup("~TGeoElementTable",1695,G__G__Geom1_151_1_2,(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_151_2_2,(int)('u'),G__get_linked_tagnum(&G__G__Geom1LN_TGeoElementTable),-1,1,1,1,1,0,"u 'TGeoElementTable' - 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__G__Geom1_152_1_0,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_152_2_0,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("Z",90,G__G__Geom1_152_3_0,105,-1,G__defined_typename("Int_t"),0,0,1,1,8,"",(char*)NULL,(void*)NULL,0);
   G__memfunc_setup("A",65,G__G__Geom1_152_4_0,100,-1,G__defined_typename("Double_t"),0,0,1,1,8,"",(char*)NULL,(void*)NULL,0);
   G__memfunc_setup("IsDefined",875,G__G__Geom1_152_5_0,103,-1,G__defined_typename("Bool_t"),0,0,1,1,8,"",(char*)NULL,(void*)NULL,0);
   G__memfunc_setup("IsUsed",589,G__G__Geom1_152_6_0,103,-1,G__defined_typename("Bool_t"),0,0,1,1,8,"",(char*)NULL,(void*)NULL,0);
   G__memfunc_setup("SetDefined",987,G__G__Geom1_152_7_0,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_152_8_0,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_152_9_0,85,G__get_linked_tagnum(&G__G__Geom1LN_TGeoElementTable),-1,0,0,1,1,8,"",(char*)NULL,(void*)NULL,0);
   G__memfunc_setup("Class",502,G__G__Geom1_152_0_1,85,G__get_linked_tagnum(&G__G__Geom1LN_TClass),-1,0,0,3,1,0,"",(char*)NULL,(void*)(TClass* (*)())(&TGeoElement::Class),0);
   G__memfunc_setup("Class_Name",982,G__G__Geom1_152_1_1,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)(const char* (*)())(&TGeoElement::Class_Name),0);
   G__memfunc_setup("Class_Version",1339,G__G__Geom1_152_2_1,115,-1,G__defined_typename("Version_t"),0,0,3,1,0,"",(char*)NULL,(void*)(Version_t (*)())(&TGeoElement::Class_Version),0);
   G__memfunc_setup("Dictionary",1046,G__G__Geom1_152_3_1,121,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)(void (*)())(&TGeoElement::Dictionary),0);
   G__memfunc_setup("IsA",253,G__G__Geom1_152_4_1,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_152_5_1,121,-1,-1,0,2,1,1,0,
"u 'TMemberInspector' - 1 - insp C - - 0 - parent",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("Streamer",835,G__G__Geom1_152_6_1,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_152_7_1,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_152_8_1,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)(const char* (*)())(&TGeoElement::DeclFileName),0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Geom1_152_9_1,105,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)(int (*)())(&TGeoElement::ImplFileLine),0);
   G__memfunc_setup("ImplFileName",1171,G__G__Geom1_152_0_2,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)(const char* (*)())(&TGeoElement::ImplFileName),0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Geom1_152_1_2,105,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)(int (*)())(&TGeoElement::DeclFileLine),0);
   // automatic copy constructor
   G__memfunc_setup("TGeoElement",1081,G__G__Geom1_152_2_2,(int)('i'),G__get_linked_tagnum(&G__G__Geom1LN_TGeoElement),-1,0,1,1,1,0,"u 'TGeoElement' - 11 - -",(char*)NULL,(void*)NULL,0);
   // automatic destructor
   G__memfunc_setup("~TGeoElement",1207,G__G__Geom1_152_3_2,(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_152_4_2,(int)('u'),G__get_linked_tagnum(&G__G__Geom1LN_TGeoElement),-1,1,1,1,1,0,"u 'TGeoElement' - 11 - -",(char*)NULL,(void*)NULL,0);
   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__G__Geom1_154_1_0,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_154_2_0,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_154_3_0,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_154_4_0,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_154_5_0,100,-1,G__defined_typename("Double_t"),0,1,3,1,0,"d - 'Double_t' 0 - z",(char*)NULL,(void*)(Double_t (*)(Double_t))(&TGeoMaterial::Coulomb),0);
   G__memfunc_setup("GetByteCount",1213,G__G__Geom1_154_6_0,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_154_7_0,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_154_8_0,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_154_9_0,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_154_0_1,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_154_1_1,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("GetPointerName",1410,G__G__Geom1_154_2_1,67,-1,-1,0,0,1,1,8,"",(char*)NULL,(void*)NULL,0);
   G__memfunc_setup("GetRadLen",854,G__G__Geom1_154_3_1,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_154_4_1,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_154_5_1,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_154_6_1,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_154_7_1,99,-1,G__defined_typename("Char_t"),0,0,1,1,8,"",(char*)NULL,(void*)NULL,0);
   G__memfunc_setup("IsEq",370,G__G__Geom1_154_8_1,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_154_9_1,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_154_0_2,103,-1,G__defined_typename("Bool_t"),0,0,1,1,8,"",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("Print",525,G__G__Geom1_154_1_2,121,-1,-1,0,1,1,1,8,"C - 'Option_t' 10 \"\" option",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("SavePrimitive",1352,G__G__Geom1_154_2_2,121,-1,-1,0,2,1,1,0,
"u 'basic_ofstream<char,char_traits<char> >' 'ofstream' 1 - out C - 'Option_t' 10 - option",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("SetIndex",804,G__G__Geom1_154_3_2,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_154_4_2,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_154_5_2,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_154_6_2,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_154_7_2,121,-1,-1,0,1,1,1,0,"c - 'Char_t' 0 0 transparency",(char*)NULL,(void*)NULL,0);
   G__memfunc_setup("ScreenFactor",1215,G__G__Geom1_154_8_2,100,-1,G__defined_typename("Double_t"),0,1,3,1,0,"d - 'Double_t' 0 - z",(char*)NULL,(void*)(Double_t (*)(Double_t))(&TGeoMaterial::ScreenFactor),0);
   G__memfunc_setup("Class",502,G__G__Geom1_154_9_2,85,G__get_linked_tagnum(&G__G__Geom1LN_TClass),-1,0,0,3,1,0,"",(char*)NULL,(void*)(TClass* (*)())(&TGeoMaterial::Class),0);
   G__memfunc_setup("Class_Name",982,G__G__Geom1_154_0_3,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)(const char* (*)())(&TGeoMaterial::Class_Name),0);
   G__memfunc_setup("Class_Version",1339,G__G__Geom1_154_1_3,115,-1,G__defined_typename("Version_t"),0,0,3,1,0,"",(char*)NULL,(void*)(Version_t (*)())(&TGeoMaterial::Class_Version),0);
   G__memfunc_setup("Dictionary",1046,G__G__Geom1_154_2_3,121,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)(void (*)())(&TGeoMaterial::Dictionary),0);
   G__memfunc_setup("IsA",253,G__G__Geom1_154_3_3,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_154_4_3,121,-1,-1,0,2,1,1,0,
"u 'TMemberInspector' - 1 - insp C - - 0 - parent",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("Streamer",835,G__G__Geom1_154_5_3,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_154_6_3,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_154_7_3,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)(const char* (*)())(&TGeoMaterial::DeclFileName),0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Geom1_154_8_3,105,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)(int (*)())(&TGeoMaterial::ImplFileLine),0);
   G__memfunc_setup("ImplFileName",1171,G__G__Geom1_154_9_3,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)(const char* (*)())(&TGeoMaterial::ImplFileName),0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Geom1_154_0_4,105,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)(int (*)())(&TGeoMaterial::DeclFileLine),0);
   // automatic copy constructor
   G__memfunc_setup("TGeoMaterial",1182,G__G__Geom1_154_1_4,(int)('i'),G__get_linked_tagnum(&G__G__Geom1LN_TGeoMaterial),-1,0,1,1,1,0,"u 'TGeoMaterial' - 11 - -",(char*)NULL,(void*)NULL,0);
   // automatic destructor
   G__memfunc_setup("~TGeoMaterial",1308,G__G__Geom1_154_2_4,(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_154_3_4,(int)('u'),G__get_linked_tagnum(&G__G__Geom1LN_TGeoMaterial),-1,1,1,1,1,0,"u 'TGeoMaterial' - 11 - -",(char*)NULL,(void*)NULL,0);
   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__G__Geom1_156_1_0,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_156_2_0,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("DefineElement",1301,G__G__Geom1_156_3_0,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_156_4_0,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_156_5_0,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("GetByteCount",1213,G__G__Geom1_156_6_0,105,-1,G__defined_typename("Int_t"),0,0,1,1,8,"",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("GetElement",1002,G__G__Geom1_156_7_0,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_156_8_0,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_156_9_0,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_156_0_1,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_156_1_1,68,-1,G__defined_typename("Double_t"),0,0,1,1,8,"",(char*)NULL,(void*)NULL,0);
   G__memfunc_setup("IsEq",370,G__G__Geom1_156_2_1,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__G__Geom1_156_3_1,103,-1,G__defined_typename("Bool_t"),0,0,1,1,8,"",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("Print",525,G__G__Geom1_156_4_1,121,-1,-1,0,1,1,1,8,"C - 'Option_t' 10 \"\" option",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("SavePrimitive",1352,G__G__Geom1_156_5_1,121,-1,-1,0,2,1,1,0,
"u 'basic_ofstream<char,char_traits<char> >' 'ofstream' 1 - out C - 'Option_t' 10 - option",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("SetA",365,G__G__Geom1_156_6_1,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_156_7_1,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_156_8_1,85,G__get_linked_tagnum(&G__G__Geom1LN_TClass),-1,0,0,3,1,0,"",(char*)NULL,(void*)(TClass* (*)())(&TGeoMixture::Class),0);
   G__memfunc_setup("Class_Name",982,G__G__Geom1_156_9_1,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)(const char* (*)())(&TGeoMixture::Class_Name),0);
   G__memfunc_setup("Class_Version",1339,G__G__Geom1_156_0_2,115,-1,G__defined_typename("Version_t"),0,0,3,1,0,"",(char*)NULL,(void*)(Version_t (*)())(&TGeoMixture::Class_Version),0);
   G__memfunc_setup("Dictionary",1046,G__G__Geom1_156_1_2,121,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)(void (*)())(&TGeoMixture::Dictionary),0);
   G__memfunc_setup("IsA",253,G__G__Geom1_156_2_2,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_156_3_2,121,-1,-1,0,2,1,1,0,
"u 'TMemberInspector' - 1 - insp C - - 0 - parent",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("Streamer",835,G__G__Geom1_156_4_2,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_156_5_2,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_156_6_2,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)(const char* (*)())(&TGeoMixture::DeclFileName),0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Geom1_156_7_2,105,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)(int (*)())(&TGeoMixture::ImplFileLine),0);
   G__memfunc_setup("ImplFileName",1171,G__G__Geom1_156_8_2,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)(const char* (*)())(&TGeoMixture::ImplFileName),0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Geom1_156_9_2,105,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)(int (*)())(&TGeoMixture::DeclFileLine),0);
   // automatic copy constructor
   G__memfunc_setup("TGeoMixture",1117,G__G__Geom1_156_0_3,(int)('i'),G__get_linked_tagnum(&G__G__Geom1LN_TGeoMixture),-1,0,1,1,1,0,"u 'TGeoMixture' - 11 - -",(char*)NULL,(void*)NULL,0);
   // automatic destructor
   G__memfunc_setup("~TGeoMixture",1243,G__G__Geom1_156_1_3,(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_156_2_3,(int)('u'),G__get_linked_tagnum(&G__G__Geom1LN_TGeoMixture),-1,1,1,1,1,0,"u 'TGeoMixture' - 11 - -",(char*)NULL,(void*)NULL,0);
   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__G__Geom1_157_1_0,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_157_2_0,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_157_3_0,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_157_4_0,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_157_5_0,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_157_6_0,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("GetPointerName",1410,G__G__Geom1_157_7_0,67,-1,-1,0,0,1,1,8,"",(char*)NULL,(void*)NULL,0);
   G__memfunc_setup("GetMaterial",1103,G__G__Geom1_157_8_0,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__G__Geom1_157_9_0,121,-1,-1,0,2,1,1,0,
"u 'basic_ofstream<char,char_traits<char> >' 'ofstream' 1 - out C - 'Option_t' 10 - option",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("SetId",473,G__G__Geom1_157_0_1,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_157_1_1,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_157_2_1,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_157_3_1,85,G__get_linked_tagnum(&G__G__Geom1LN_TClass),-1,0,0,3,1,0,"",(char*)NULL,(void*)(TClass* (*)())(&TGeoMedium::Class),0);
   G__memfunc_setup("Class_Name",982,G__G__Geom1_157_4_1,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)(const char* (*)())(&TGeoMedium::Class_Name),0);
   G__memfunc_setup("Class_Version",1339,G__G__Geom1_157_5_1,115,-1,G__defined_typename("Version_t"),0,0,3,1,0,"",(char*)NULL,(void*)(Version_t (*)())(&TGeoMedium::Class_Version),0);
   G__memfunc_setup("Dictionary",1046,G__G__Geom1_157_6_1,121,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)(void (*)())(&TGeoMedium::Dictionary),0);
   G__memfunc_setup("IsA",253,G__G__Geom1_157_7_1,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_157_8_1,121,-1,-1,0,2,1,1,0,
"u 'TMemberInspector' - 1 - insp C - - 0 - parent",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("Streamer",835,G__G__Geom1_157_9_1,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_2,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_1_2,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)(const char* (*)())(&TGeoMedium::DeclFileName),0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Geom1_157_2_2,105,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)(int (*)())(&TGeoMedium::ImplFileLine),0);
   G__memfunc_setup("ImplFileName",1171,G__G__Geom1_157_3_2,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)(const char* (*)())(&TGeoMedium::ImplFileName),0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Geom1_157_4_2,105,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)(int (*)())(&TGeoMedium::DeclFileLine),0);
   // automatic copy constructor
   G__memfunc_setup("TGeoMedium",976,G__G__Geom1_157_5_2,(int)('i'),G__get_linked_tagnum(&G__G__Geom1LN_TGeoMedium),-1,0,1,1,1,0,"u 'TGeoMedium' - 11 - -",(char*)NULL,(void*)NULL,0);
   // automatic destructor
   G__memfunc_setup("~TGeoMedium",1102,G__G__Geom1_157_6_2,(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_157_7_2,(int)('u'),G__get_linked_tagnum(&G__G__Geom1LN_TGeoMedium),-1,1,1,1,1,0,"u 'TGeoMedium' - 11 - -",(char*)NULL,(void*)NULL,0);
   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_160_1_0,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_160_2_0,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_160_3_0,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_160_4_0,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_160_5_0,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_160_6_0,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_160_7_0,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_160_8_0,121,-1,-1,0,1,1,1,0,"U 'TGeoTranslation' - 10 - other",(char*)NULL,(void*)NULL,0);
   G__memfunc_setup("Inverse",732,G__G__Geom1_160_9_0,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__G__Geom1_160_0_1,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_160_1_1,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("MasterToLocal",1306,G__G__Geom1_160_2_1,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_160_3_1,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("LocalToMasterBomb",1690,G__G__Geom1_160_4_1,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("MasterToLocalBomb",1690,G__G__Geom1_160_5_1,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__G__Geom1_160_6_1,121,-1,-1,0,1,1,1,0,"d - 'Double_t' 0 - angle",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("RotateY",712,G__G__Geom1_160_7_1,121,-1,-1,0,1,1,1,0,"d - 'Double_t' 0 - angle",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("RotateZ",713,G__G__Geom1_160_8_1,121,-1,-1,0,1,1,1,0,"d - 'Double_t' 0 - angle",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("SavePrimitive",1352,G__G__Geom1_160_9_1,121,-1,-1,0,2,1,1,0,
"u 'basic_ofstream<char,char_traits<char> >' 'ofstream' 1 - out C - 'Option_t' 10 - option",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("Subtract",840,G__G__Geom1_160_0_2,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_160_1_2,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_160_2_2,121,-1,-1,0,1,1,1,0,"u 'TGeoMatrix' - 11 - other",(char*)NULL,(void*)NULL,0);
   G__memfunc_setup("SetDx",488,G__G__Geom1_160_3_2,121,-1,-1,0,1,1,1,0,"d - 'Double_t' 0 - dx",(char*)NULL,(void*)NULL,0);
   G__memfunc_setup("SetDy",489,G__G__Geom1_160_4_2,121,-1,-1,0,1,1,1,0,"d - 'Double_t' 0 - dy",(char*)NULL,(void*)NULL,0);
   G__memfunc_setup("SetDz",490,G__G__Geom1_160_5_2,121,-1,-1,0,1,1,1,0,"d - 'Double_t' 0 - dz",(char*)NULL,(void*)NULL,0);
   G__memfunc_setup("GetTranslation",1455,G__G__Geom1_160_6_2,68,-1,G__defined_typename("Double_t"),0,0,1,1,9,"",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("GetRotationMatrix",1765,G__G__Geom1_160_7_2,68,-1,G__defined_typename("Double_t"),0,0,1,1,9,"",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("GetScale",776,G__G__Geom1_160_8_2,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_160_9_2,85,G__get_linked_tagnum(&G__G__Geom1LN_TClass),-1,0,0,3,1,0,"",(char*)NULL,(void*)(TClass* (*)())(&TGeoTranslation::Class),0);
   G__memfunc_setup("Class_Name",982,G__G__Geom1_160_0_3,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)(const char* (*)())(&TGeoTranslation::Class_Name),0);
   G__memfunc_setup("Class_Version",1339,G__G__Geom1_160_1_3,115,-1,G__defined_typename("Version_t"),0,0,3,1,0,"",(char*)NULL,(void*)(Version_t (*)())(&TGeoTranslation::Class_Version),0);
   G__memfunc_setup("Dictionary",1046,G__G__Geom1_160_2_3,121,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)(void (*)())(&TGeoTranslation::Dictionary),0);
   G__memfunc_setup("IsA",253,G__G__Geom1_160_3_3,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_160_4_3,121,-1,-1,0,2,1,1,0,
"u 'TMemberInspector' - 1 - insp C - - 0 - parent",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("Streamer",835,G__G__Geom1_160_5_3,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_6_3,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_7_3,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)(const char* (*)())(&TGeoTranslation::DeclFileName),0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Geom1_160_8_3,105,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)(int (*)())(&TGeoTranslation::ImplFileLine),0);
   G__memfunc_setup("ImplFileName",1171,G__G__Geom1_160_9_3,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)(const char* (*)())(&TGeoTranslation::ImplFileName),0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Geom1_160_0_4,105,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)(int (*)())(&TGeoTranslation::DeclFileLine),0);
   // automatic destructor
   G__memfunc_setup("~TGeoTranslation",1660,G__G__Geom1_160_1_4,(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_161_2_0,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_161_3_0,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_161_4_0,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_161_5_0,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_161_6_0,105,G__get_linked_tagnum(&G__G__Geom1LN_TGeoRotation),-1,0,4,1,1,0,
"C - - 10 - name d - 'Double_t' 0 - alpha "
"d - 'Double_t' 0 - beta d - 'Double_t' 0 - gamma",(char*)NULL,(void*)NULL,0);
   G__memfunc_setup("TGeoRotation",1215,G__G__Geom1_161_7_0,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_161_8_0,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_161_9_0,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_161_0_1,103,-1,G__defined_typename("Bool_t"),0,0,1,1,8,"",(char*)NULL,(void*)NULL,0);
   G__memfunc_setup("Inverse",732,G__G__Geom1_161_1_1,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__G__Geom1_161_2_1,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_161_3_1,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_161_4_1,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_161_5_1,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("GetPhiRotation",1425,G__G__Geom1_161_6_1,100,-1,G__defined_typename("Double_t"),0,0,1,1,8,"",(char*)NULL,(void*)NULL,0);
   G__memfunc_setup("LocalToMaster",1306,G__G__Geom1_161_7_1,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_161_8_1,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("MasterToLocal",1306,G__G__Geom1_161_9_1,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_161_0_2,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("LocalToMasterBomb",1690,G__G__Geom1_161_1_2,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("MasterToLocalBomb",1690,G__G__Geom1_161_2_2,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_161_3_2,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__G__Geom1_161_4_2,121,-1,-1,0,1,1,1,0,"d - 'Double_t' 0 - angle",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("RotateY",712,G__G__Geom1_161_5_2,121,-1,-1,0,1,1,1,0,"d - 'Double_t' 0 - angle",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("RotateZ",713,G__G__Geom1_161_6_2,121,-1,-1,0,1,1,1,0,"d - 'Double_t' 0 - angle",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("SavePrimitive",1352,G__G__Geom1_161_7_2,121,-1,-1,0,2,1,1,0,
"u 'basic_ofstream<char,char_traits<char> >' 'ofstream' 1 - out C - 'Option_t' 10 - option",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("SetAngles",902,G__G__Geom1_161_8_2,121,-1,-1,0,3,1,1,0,
"d - 'Double_t' 0 - alpha d - 'Double_t' 0 - beta "
"d - 'Double_t' 0 - gamma",(char*)NULL,(void*)NULL,0);
   G__memfunc_setup("SetAngles",902,G__G__Geom1_161_9_2,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_161_0_3,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_161_1_3,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_161_2_3,121,-1,-1,0,1,1,1,8,"D - 'Double_t' 0 - invmat",(char*)NULL,(void*)NULL,0);
   G__memfunc_setup("GetTranslation",1455,G__G__Geom1_161_3_3,68,-1,G__defined_typename("Double_t"),0,0,1,1,9,"",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("GetRotationMatrix",1765,G__G__Geom1_161_4_3,68,-1,G__defined_typename("Double_t"),0,0,1,1,9,"",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("GetScale",776,G__G__Geom1_161_5_3,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_161_6_3,85,G__get_linked_tagnum(&G__G__Geom1LN_TClass),-1,0,0,3,1,0,"",(char*)NULL,(void*)(TClass* (*)())(&TGeoRotation::Class),0);
   G__memfunc_setup("Class_Name",982,G__G__Geom1_161_7_3,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)(const char* (*)())(&TGeoRotation::Class_Name),0);
   G__memfunc_setup("Class_Version",1339,G__G__Geom1_161_8_3,115,-1,G__defined_typename("Version_t"),0,0,3,1,0,"",(char*)NULL,(void*)(Version_t (*)())(&TGeoRotation::Class_Version),0);
   G__memfunc_setup("Dictionary",1046,G__G__Geom1_161_9_3,121,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)(void (*)())(&TGeoRotation::Dictionary),0);
   G__memfunc_setup("IsA",253,G__G__Geom1_161_0_4,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_161_1_4,121,-1,-1,0,2,1,1,0,
"u 'TMemberInspector' - 1 - insp C - - 0 - parent",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("Streamer",835,G__G__Geom1_161_2_4,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_3_4,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_4_4,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)(const char* (*)())(&TGeoRotation::DeclFileName),0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Geom1_161_5_4,105,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)(int (*)())(&TGeoRotation::ImplFileLine),0);
   G__memfunc_setup("ImplFileName",1171,G__G__Geom1_161_6_4,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)(const char* (*)())(&TGeoRotation::ImplFileName),0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Geom1_161_7_4,105,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)(int (*)())(&TGeoRotation::DeclFileLine),0);
   // automatic destructor
   G__memfunc_setup("~TGeoRotation",1341,G__G__Geom1_161_8_4,(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_162_1_0,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_162_2_0,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_162_3_0,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_162_4_0,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__G__Geom1_162_5_0,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_162_6_0,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("Normalize",945,G__G__Geom1_162_7_0,103,-1,G__defined_typename("Bool_t"),0,0,1,1,0,"",(char*)NULL,(void*)NULL,0);
   G__memfunc_setup("GetTranslation",1455,G__G__Geom1_162_8_0,68,-1,G__defined_typename("Double_t"),0,0,1,1,9,"",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("GetRotationMatrix",1765,G__G__Geom1_162_9_0,68,-1,G__defined_typename("Double_t"),0,0,1,1,9,"",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("GetScale",776,G__G__Geom1_162_0_1,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_162_1_1,85,G__get_linked_tagnum(&G__G__Geom1LN_TClass),-1,0,0,3,1,0,"",(char*)NULL,(void*)(TClass* (*)())(&TGeoScale::Class),0);
   G__memfunc_setup("Class_Name",982,G__G__Geom1_162_2_1,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)(const char* (*)())(&TGeoScale::Class_Name),0);
   G__memfunc_setup("Class_Version",1339,G__G__Geom1_162_3_1,115,-1,G__defined_typename("Version_t"),0,0,3,1,0,"",(char*)NULL,(void*)(Version_t (*)())(&TGeoScale::Class_Version),0);
   G__memfunc_setup("Dictionary",1046,G__G__Geom1_162_4_1,121,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)(void (*)())(&TGeoScale::Dictionary),0);
   G__memfunc_setup("IsA",253,G__G__Geom1_162_5_1,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_162_6_1,121,-1,-1,0,2,1,1,0,
"u 'TMemberInspector' - 1 - insp C - - 0 - parent",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("Streamer",835,G__G__Geom1_162_7_1,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_162_8_1,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_162_9_1,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)(const char* (*)())(&TGeoScale::DeclFileName),0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Geom1_162_0_2,105,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)(int (*)())(&TGeoScale::ImplFileLine),0);
   G__memfunc_setup("ImplFileName",1171,G__G__Geom1_162_1_2,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)(const char* (*)())(&TGeoScale::ImplFileName),0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Geom1_162_2_2,105,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)(int (*)())(&TGeoScale::DeclFileLine),0);
   // automatic destructor
   G__memfunc_setup("~TGeoScale",981,G__G__Geom1_162_3_2,(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_162_4_2,(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_163_1_0,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_163_2_0,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_163_3_0,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_163_4_0,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_163_5_0,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_163_6_0,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_163_7_0,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_163_8_0,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_163_9_0,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__G__Geom1_163_0_1,121,-1,-1,0,1,1,1,0,"C - 'Option_t' 10 \"\" option",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("Inverse",732,G__G__Geom1_163_1_1,117,G__get_linked_tagnum(&G__G__Geom1LN_TGeoMatrix),-1,1,0,1,1,8,"",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("RegisterYourself",1694,G__G__Geom1_163_2_1,121,-1,-1,0,0,1,1,0,"",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("RotateX",711,G__G__Geom1_163_3_1,121,-1,-1,0,1,1,1,0,"d - 'Double_t' 0 - angle",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("RotateY",712,G__G__Geom1_163_4_1,121,-1,-1,0,1,1,1,0,"d - 'Double_t' 0 - angle",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("RotateZ",713,G__G__Geom1_163_5_1,121,-1,-1,0,1,1,1,0,"d - 'Double_t' 0 - angle",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("SavePrimitive",1352,G__G__Geom1_163_6_1,121,-1,-1,0,2,1,1,0,
"u 'basic_ofstream<char,char_traits<char> >' 'ofstream' 1 - out C - 'Option_t' 10 - option",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("SetTranslation",1467,G__G__Geom1_163_7_1,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_163_8_1,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_163_9_1,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_163_0_2,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_163_1_2,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_163_2_2,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__G__Geom1_163_3_2,68,-1,G__defined_typename("Double_t"),0,0,1,1,9,"",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("GetRotationMatrix",1765,G__G__Geom1_163_4_2,68,-1,G__defined_typename("Double_t"),0,0,1,1,9,"",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("GetScale",776,G__G__Geom1_163_5_2,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_163_6_2,85,G__get_linked_tagnum(&G__G__Geom1LN_TClass),-1,0,0,3,1,0,"",(char*)NULL,(void*)(TClass* (*)())(&TGeoCombiTrans::Class),0);
   G__memfunc_setup("Class_Name",982,G__G__Geom1_163_7_2,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)(const char* (*)())(&TGeoCombiTrans::Class_Name),0);
   G__memfunc_setup("Class_Version",1339,G__G__Geom1_163_8_2,115,-1,G__defined_typename("Version_t"),0,0,3,1,0,"",(char*)NULL,(void*)(Version_t (*)())(&TGeoCombiTrans::Class_Version),0);
   G__memfunc_setup("Dictionary",1046,G__G__Geom1_163_9_2,121,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)(void (*)())(&TGeoCombiTrans::Dictionary),0);
   G__memfunc_setup("IsA",253,G__G__Geom1_163_0_3,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_163_1_3,121,-1,-1,0,2,1,1,0,
"u 'TMemberInspector' - 1 - insp C - - 0 - parent",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("Streamer",835,G__G__Geom1_163_2_3,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_163_3_3,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_163_4_3,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)(const char* (*)())(&TGeoCombiTrans::DeclFileName),0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Geom1_163_5_3,105,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)(int (*)())(&TGeoCombiTrans::ImplFileLine),0);
   G__memfunc_setup("ImplFileName",1171,G__G__Geom1_163_6_3,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)(const char* (*)())(&TGeoCombiTrans::ImplFileName),0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Geom1_163_7_3,105,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)(int (*)())(&TGeoCombiTrans::DeclFileLine),0);
   // automatic destructor
   G__memfunc_setup("~TGeoCombiTrans",1503,G__G__Geom1_163_8_3,(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_164_1_0,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_164_2_0,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_164_3_0,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_164_4_0,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__G__Geom1_164_5_0,121,-1,-1,0,1,1,1,0,"C - 'Option_t' 10 \"\" option",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("Inverse",732,G__G__Geom1_164_6_0,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_164_7_0,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_164_8_0,121,-1,-1,0,1,1,1,0,"D - 'Double_t' 0 - scale",(char*)NULL,(void*)NULL,0);
   G__memfunc_setup("Normalize",945,G__G__Geom1_164_9_0,103,-1,G__defined_typename("Bool_t"),0,0,1,1,0,"",(char*)NULL,(void*)NULL,0);
   G__memfunc_setup("GetScale",776,G__G__Geom1_164_0_1,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_1_1,85,G__get_linked_tagnum(&G__G__Geom1LN_TClass),-1,0,0,3,1,0,"",(char*)NULL,(void*)(TClass* (*)())(&TGeoGenTrans::Class),0);
   G__memfunc_setup("Class_Name",982,G__G__Geom1_164_2_1,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)(const char* (*)())(&TGeoGenTrans::Class_Name),0);
   G__memfunc_setup("Class_Version",1339,G__G__Geom1_164_3_1,115,-1,G__defined_typename("Version_t"),0,0,3,1,0,"",(char*)NULL,(void*)(Version_t (*)())(&TGeoGenTrans::Class_Version),0);
   G__memfunc_setup("Dictionary",1046,G__G__Geom1_164_4_1,121,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)(void (*)())(&TGeoGenTrans::Dictionary),0);
   G__memfunc_setup("IsA",253,G__G__Geom1_164_5_1,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_164_6_1,121,-1,-1,0,2,1,1,0,
"u 'TMemberInspector' - 1 - insp C - - 0 - parent",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("Streamer",835,G__G__Geom1_164_7_1,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_8_1,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_9_1,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)(const char* (*)())(&TGeoGenTrans::DeclFileName),0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Geom1_164_0_2,105,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)(int (*)())(&TGeoGenTrans::ImplFileLine),0);
   G__memfunc_setup("ImplFileName",1171,G__G__Geom1_164_1_2,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)(const char* (*)())(&TGeoGenTrans::ImplFileName),0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Geom1_164_2_2,105,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)(int (*)())(&TGeoGenTrans::DeclFileLine),0);
   // automatic copy constructor
   G__memfunc_setup("TGeoGenTrans",1169,G__G__Geom1_164_3_2,(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_164_4_2,(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_164_5_2,(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_165_1_0,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_165_2_0,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__G__Geom1_165_3_0,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__G__Geom1_165_4_0,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_165_5_0,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("MasterToLocal",1306,G__G__Geom1_165_6_0,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_165_7_0,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("LocalToMasterBomb",1690,G__G__Geom1_165_8_0,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("MasterToLocalBomb",1690,G__G__Geom1_165_9_0,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__G__Geom1_165_0_1,68,-1,G__defined_typename("Double_t"),0,0,1,1,9,"",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("GetRotationMatrix",1765,G__G__Geom1_165_1_1,68,-1,G__defined_typename("Double_t"),0,0,1,1,9,"",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("GetScale",776,G__G__Geom1_165_2_1,68,-1,G__defined_typename("Double_t"),0,0,1,1,9,"",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("SavePrimitive",1352,G__G__Geom1_165_3_1,121,-1,-1,0,2,1,1,0,
"u 'basic_ofstream<char,char_traits<char> >' 'ofstream' 1 - - C - 'Option_t' 10 - -",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("Class",502,G__G__Geom1_165_4_1,85,G__get_linked_tagnum(&G__G__Geom1LN_TClass),-1,0,0,3,1,0,"",(char*)NULL,(void*)(TClass* (*)())(&TGeoIdentity::Class),0);
   G__memfunc_setup("Class_Name",982,G__G__Geom1_165_5_1,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)(const char* (*)())(&TGeoIdentity::Class_Name),0);
   G__memfunc_setup("Class_Version",1339,G__G__Geom1_165_6_1,115,-1,G__defined_typename("Version_t"),0,0,3,1,0,"",(char*)NULL,(void*)(Version_t (*)())(&TGeoIdentity::Class_Version),0);
   G__memfunc_setup("Dictionary",1046,G__G__Geom1_165_7_1,121,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)(void (*)())(&TGeoIdentity::Dictionary),0);
   G__memfunc_setup("IsA",253,G__G__Geom1_165_8_1,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_165_9_1,121,-1,-1,0,2,1,1,0,
"u 'TMemberInspector' - 1 - insp C - - 0 - parent",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("Streamer",835,G__G__Geom1_165_0_2,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_1_2,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_2_2,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)(const char* (*)())(&TGeoIdentity::DeclFileName),0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Geom1_165_3_2,105,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)(int (*)())(&TGeoIdentity::ImplFileLine),0);
   G__memfunc_setup("ImplFileName",1171,G__G__Geom1_165_4_2,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)(const char* (*)())(&TGeoIdentity::ImplFileName),0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Geom1_165_5_2,105,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)(int (*)())(&TGeoIdentity::DeclFileLine),0);
   // automatic copy constructor
   G__memfunc_setup("TGeoIdentity",1209,G__G__Geom1_165_6_2,(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_165_7_2,(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_165_8_2,(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_169_2_0,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_169_3_0,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_169_4_0,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_169_5_0,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("ComputeBBox",1096,G__G__Geom1_169_6_0,121,-1,-1,0,0,1,1,0,"",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("ComputeNormal",1350,G__G__Geom1_169_7_0,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__G__Geom1_169_8_0,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("CouldBeCrossed",1393,G__G__Geom1_169_9_0,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__G__Geom1_169_0_1,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__G__Geom1_169_1_1,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_169_2_1,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__G__Geom1_169_3_1,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__G__Geom1_169_4_1,67,-1,-1,0,1,1,1,9,"i - 'Int_t' 0 - iaxis",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("GetAxisRange",1186,G__G__Geom1_169_5_1,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__G__Geom1_169_6_1,121,-1,-1,0,1,1,1,8,"D - 'Double_t' 0 - param",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("GetBuffer3D",1009,G__G__Geom1_169_7_1,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_169_8_1,105,-1,G__defined_typename("Int_t"),0,0,1,1,8,"",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("GetFittingBox",1310,G__G__Geom1_169_9_1,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__G__Geom1_169_0_2,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__G__Geom1_169_1_2,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_169_2_2,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_169_3_2,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_169_4_2,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_169_5_2,68,-1,G__defined_typename("Double_t"),0,0,1,1,9,"",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("InspectShape",1223,G__G__Geom1_169_6_2,121,-1,-1,0,0,1,1,8,"",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("IsCylType",902,G__G__Geom1_169_7_2,103,-1,G__defined_typename("Bool_t"),0,0,1,1,8,"",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("IsValidBox",981,G__G__Geom1_169_8_2,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_169_9_2,103,-1,G__defined_typename("Bool_t"),0,0,1,1,8,"",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("MakeBuffer3D",1103,G__G__Geom1_169_0_3,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__G__Geom1_169_1_3,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__G__Geom1_169_2_3,121,-1,-1,0,2,1,1,0,
"u 'basic_ofstream<char,char_traits<char> >' 'ofstream' 1 - out C - 'Option_t' 10 - option",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("SetBoxDimensions",1646,G__G__Geom1_169_3_3,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__G__Geom1_169_4_3,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_169_5_3,121,-1,-1,0,1,1,1,8,"D - 'Double_t' 0 - points",(char*)NULL,(void*)NULL,0);
   G__memfunc_setup("SetPoints",937,G__G__Geom1_169_6_3,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_169_7_3,121,-1,-1,0,1,1,1,8,"F - 'Float_t' 0 - points",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("SetSegsAndPols",1391,G__G__Geom1_169_8_3,121,-1,-1,0,1,1,1,8,"u 'TBuffer3D' - 1 - buffer",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("Sizeof3D",743,G__G__Geom1_169_9_3,121,-1,-1,0,0,1,1,8,"",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("Class",502,G__G__Geom1_169_0_4,85,G__get_linked_tagnum(&G__G__Geom1LN_TClass),-1,0,0,3,1,0,"",(char*)NULL,(void*)(TClass* (*)())(&TGeoBBox::Class),0);
   G__memfunc_setup("Class_Name",982,G__G__Geom1_169_1_4,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)(const char* (*)())(&TGeoBBox::Class_Name),0);
   G__memfunc_setup("Class_Version",1339,G__G__Geom1_169_2_4,115,-1,G__defined_typename("Version_t"),0,0,3,1,0,"",(char*)NULL,(void*)(Version_t (*)())(&TGeoBBox::Class_Version),0);
   G__memfunc_setup("Dictionary",1046,G__G__Geom1_169_3_4,121,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)(void (*)())(&TGeoBBox::Dictionary),0);
   G__memfunc_setup("IsA",253,G__G__Geom1_169_4_4,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_169_5_4,121,-1,-1,0,2,1,1,0,
"u 'TMemberInspector' - 1 - insp C - - 0 - parent",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("Streamer",835,G__G__Geom1_169_6_4,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_7_4,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_8_4,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)(const char* (*)())(&TGeoBBox::DeclFileName),0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Geom1_169_9_4,105,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)(int (*)())(&TGeoBBox::ImplFileLine),0);
   G__memfunc_setup("ImplFileName",1171,G__G__Geom1_169_0_5,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)(const char* (*)())(&TGeoBBox::ImplFileName),0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Geom1_169_1_5,105,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)(int (*)())(&TGeoBBox::DeclFileLine),0);
   // automatic copy constructor
   G__memfunc_setup("TGeoBBox",730,G__G__Geom1_169_2_5,(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_169_3_5,(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_4_5,(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__G__Geom1_170_1_0,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_170_2_0,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_170_3_0,121,-1,-1,0,1,1,1,8,"i - 'Int_t' 0 - inode",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("Browse",626,G__G__Geom1_170_4_0,121,-1,-1,0,1,1,1,0,"U 'TBrowser' - 0 - b",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("CheckShapes",1090,G__G__Geom1_170_5_0,121,-1,-1,0,0,1,1,0,"",(char*)NULL,(void*)NULL,0);
   G__memfunc_setup("ClearNodes",992,G__G__Geom1_170_6_0,121,-1,-1,0,0,1,1,0,"",(char*)NULL,(void*)NULL,0);
   G__memfunc_setup("ClearShape",984,G__G__Geom1_170_7_0,121,-1,-1,0,0,1,1,0,"",(char*)NULL,(void*)NULL,0);
   G__memfunc_setup("CleanAll",764,G__G__Geom1_170_8_0,121,-1,-1,0,0,1,1,0,"",(char*)NULL,(void*)NULL,0);
   G__memfunc_setup("CloneVolume",1129,G__G__Geom1_170_9_0,85,G__get_linked_tagnum(&G__G__Geom1LN_TGeoVolume),-1,0,0,1,1,8,"",(char*)NULL,(void*)NULL,0);
   G__memfunc_setup("CheckGeometry",1322,G__G__Geom1_170_0_1,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_170_1_1,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_170_2_1,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_170_3_1,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_170_4_1,103,-1,G__defined_typename("Bool_t"),0,0,1,1,8,"",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("IsFolder",792,G__G__Geom1_170_5_1,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_170_6_1,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_170_7_1,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_170_8_1,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_170_9_1,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_170_0_2,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_170_1_2,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__G__Geom1_170_2_2,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__G__Geom1_170_3_2,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_170_4_2,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_170_5_2,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__G__Geom1_170_6_2,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_170_7_2,121,-1,-1,0,0,1,1,8,"",(char*)NULL,(void*)NULL,0);
   G__memfunc_setup("PrintVoxels",1166,G__G__Geom1_170_8_2,121,-1,-1,0,0,1,1,8,"","*MENU*",(void*)NULL,0);
   G__memfunc_setup("ExecuteEvent",1237,G__G__Geom1_170_9_2,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("IsCylVoxels",1125,G__G__Geom1_170_0_3,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_170_1_3,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_170_2_3,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_170_3_3,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_170_4_3,103,-1,G__defined_typename("Bool_t"),0,0,1,1,8,"",(char*)NULL,(void*)NULL,0);
   G__memfunc_setup("IsVisibleDaughters",1841,G__G__Geom1_170_5_3,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_170_6_3,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_170_7_3,103,-1,G__defined_typename("Bool_t"),0,0,1,1,8,"",(char*)NULL,(void*)NULL,0);
   G__memfunc_setup("FindNode",775,G__G__Geom1_170_8_3,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_170_9_3,121,-1,-1,0,0,1,1,8,"",(char*)NULL,(void*)NULL,0);
   G__memfunc_setup("FindMatrixOfDaughterVolume",2647,G__G__Geom1_170_0_4,103,-1,G__defined_typename("Bool_t"),0,1,1,1,8,"U 'TGeoVolume' - 0 - vol",(char*)NULL,(void*)NULL,0);
   G__memfunc_setup("GetNodes",793,G__G__Geom1_170_1_4,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_170_2_4,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_170_3_4,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_170_4_4,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_170_5_4,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_170_6_4,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_170_7_4,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_170_8_4,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_170_9_4,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_170_0_5,85,G__get_linked_tagnum(&G__G__Geom1LN_TGeoVoxelFinder),-1,0,0,1,1,8,"",(char*)NULL,(void*)NULL,0);
   G__memfunc_setup("GetIndex",792,G__G__Geom1_170_1_5,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_170_2_5,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_170_3_5,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_170_4_5,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_170_5_5,105,-1,G__defined_typename("Int_t"),0,0,1,1,8,"",(char*)NULL,(void*)NULL,0);
   G__memfunc_setup("GetObjectInfo",1283,G__G__Geom1_170_6_5,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_170_7_5,103,-1,G__defined_typename("Bool_t"),0,0,1,1,8,"",(char*)NULL,(void*)NULL,0);
   G__memfunc_setup("GetOption",921,G__G__Geom1_170_8_5,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_170_9_5,67,-1,-1,0,0,1,1,8,"",(char*)NULL,(void*)NULL,0);
   G__memfunc_setup("GetTransparency",1562,G__G__Geom1_170_0_6,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_170_1_6,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_170_2_6,121,-1,-1,0,0,1,1,0,"","*MENU*",(void*)NULL,0);
   G__memfunc_setup("Gsord",511,G__G__Geom1_170_3_6,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_170_4_6,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_170_5_6,121,-1,-1,0,0,1,1,8,"","*MENU*",(void*)NULL,0);
   G__memfunc_setup("InspectShape",1223,G__G__Geom1_170_6_6,121,-1,-1,0,0,1,1,8,"","*MENU*",(void*)NULL,0);
   G__memfunc_setup("MakeCopyVolume",1425,G__G__Geom1_170_7_6,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_170_8_6,121,-1,-1,0,1,1,1,0,"U 'TGeoVolume' - 10 - other",(char*)NULL,(void*)NULL,0);
   G__memfunc_setup("OptimizeVoxels",1490,G__G__Geom1_170_9_6,103,-1,G__defined_typename("Bool_t"),0,0,1,1,0,"","*MENU*",(void*)NULL,0);
   G__memfunc_setup("RandomPoints",1246,G__G__Geom1_170_0_7,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_170_1_7,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_170_2_7,121,-1,-1,0,1,1,1,0,"g - 'Bool_t' 0 kTRUE flag","*TOGGLE* *GETTER=IsRaytracing",(void*)NULL,0);
   G__memfunc_setup("SaveAs",579,G__G__Geom1_170_3_7,121,-1,-1,0,1,1,1,0,"C - - 10 - filename","*MENU*",(void*)NULL,0);
   G__memfunc_setup("SavePrimitive",1352,G__G__Geom1_170_4_7,121,-1,-1,0,2,1,1,0,
"u 'basic_ofstream<char,char_traits<char> >' 'ofstream' 1 - out C - 'Option_t' 10 - option",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("SetAsTopVolume",1419,G__G__Geom1_170_5_7,121,-1,-1,0,0,1,1,0,"","*TOGGLE* *GETTER=IsTopVolume",(void*)NULL,0);
   G__memfunc_setup("SetCurrentPoint",1561,G__G__Geom1_170_6_7,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_170_7_7,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_170_8_7,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_170_9_7,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_170_0_8,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_170_1_8,121,-1,-1,0,1,1,1,0,"U 'TObject' - 10 - field",(char*)NULL,(void*)NULL,0);
   G__memfunc_setup("SetOption",933,G__G__Geom1_170_2_8,121,-1,-1,0,1,1,1,0,"C - - 10 - option",(char*)NULL,(void*)NULL,0);
   G__memfunc_setup("SetVisibility",1364,G__G__Geom1_170_3_8,121,-1,-1,0,1,1,1,0,"g - 'Bool_t' 0 kTRUE vis","*TOGGLE* *GETTER=IsVisible",(void*)NULL,1);
   G__memfunc_setup("SetLineColor",1203,G__G__Geom1_170_4_8,121,-1,-1,0,1,1,1,0,"s - 'Color_t' 0 - lcolor",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("SetLineStyle",1221,G__G__Geom1_170_5_8,121,-1,-1,0,1,1,1,0,"s - 'Style_t' 0 - lstyle",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("SetLineWidth",1204,G__G__Geom1_170_6_8,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_170_7_8,121,-1,-1,0,0,1,1,0,"",(char*)NULL,(void*)NULL,0);
   G__memfunc_setup("SetMedium",909,G__G__Geom1_170_8_8,121,-1,-1,0,1,1,1,0,"U 'TGeoMedium' - 10 - medium",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("SetVoxelFinder",1426,G__G__Geom1_170_9_8,121,-1,-1,0,1,1,1,0,"U 'TGeoVoxelFinder' - 10 - finder",(char*)NULL,(void*)NULL,0);
   G__memfunc_setup("SetFinder",900,G__G__Geom1_170_0_9,121,-1,-1,0,1,1,1,0,"U 'TGeoPatternFinder' - 10 - finder",(char*)NULL,(void*)NULL,0);
   G__memfunc_setup("SetNumber",917,G__G__Geom1_170_1_9,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_170_2_9,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_170_3_9,121,-1,-1,0,0,1,1,0,"",(char*)NULL,(void*)NULL,0);
   G__memfunc_setup("UnmarkSaved",1121,G__G__Geom1_170_4_9,121,-1,-1,0,0,1,1,0,"",(char*)NULL,(void*)NULL,0);
   G__memfunc_setup("Valid",496,G__G__Geom1_170_5_9,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_170_6_9,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_170_7_9,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_170_8_9,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_170_9_9,100,-1,G__defined_typename("Double_t"),0,2,1,1,0,
"d - 'Double_t' 0 0.01 precision C - 'Option_t' 10 \"v\" option","*MENU*",(void*)NULL,0);
   G__memfunc_setup("Class",502,G__G__Geom1_170_0_10,85,G__get_linked_tagnum(&G__G__Geom1LN_TClass),-1,0,0,3,1,0,"",(char*)NULL,(void*)(TClass* (*)())(&TGeoVolume::Class),0);
   G__memfunc_setup("Class_Name",982,G__G__Geom1_170_1_10,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)(const char* (*)())(&TGeoVolume::Class_Name),0);
   G__memfunc_setup("Class_Version",1339,G__G__Geom1_170_2_10,115,-1,G__defined_typename("Version_t"),0,0,3,1,0,"",(char*)NULL,(void*)(Version_t (*)())(&TGeoVolume::Class_Version),0);
   G__memfunc_setup("Dictionary",1046,G__G__Geom1_170_3_10,121,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)(void (*)())(&TGeoVolume::Dictionary),0);
   G__memfunc_setup("IsA",253,G__G__Geom1_170_4_10,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_170_5_10,121,-1,-1,0,2,1,1,0,
"u 'TMemberInspector' - 1 - insp C - - 0 - parent",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("Streamer",835,G__G__Geom1_170_6_10,121,-1,-1,0,1,1,1,0,"u 'TBuffer' - 1 - b",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Geom1_170_7_10,121,-1,-1,0,1,1,1,0,"u 'TBuffer' - 1 - b",(char*)NULL,(void*)NULL,0);
   G__memfunc_setup("DeclFileName",1145,G__G__Geom1_170_8_10,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)(const char* (*)())(&TGeoVolume::DeclFileName),0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Geom1_170_9_10,105,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)(int (*)())(&TGeoVolume::ImplFileLine),0);
   G__memfunc_setup("ImplFileName",1171,G__G__Geom1_170_0_11,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)(const char* (*)())(&TGeoVolume::ImplFileName),0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Geom1_170_1_11,105,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)(int (*)())(&TGeoVolume::DeclFileLine),0);
   // automatic copy constructor
   G__memfunc_setup("TGeoVolume",999,G__G__Geom1_170_2_11,(int)('i'),G__get_linked_tagnum(&G__G__Geom1LN_TGeoVolume),-1,0,1,1,1,0,"u 'TGeoVolume' - 11 - -",(char*)NULL,(void*)NULL,0);
   // automatic destructor
   G__memfunc_setup("~TGeoVolume",1125,G__G__Geom1_170_3_11,(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_170_4_11,(int)('u'),G__get_linked_tagnum(&G__G__Geom1LN_TGeoVolume),-1,1,1,1,1,0,"u 'TGeoVolume' - 11 - -",(char*)NULL,(void*)NULL,0);
   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("Browse",626,G__G__Geom1_174_3_0,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_174_4_0,121,-1,-1,0,0,1,1,8,"",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("CheckShapes",1090,G__G__Geom1_174_5_0,121,-1,-1,0,0,1,1,0,"",(char*)NULL,(void*)NULL,0);
   G__memfunc_setup("Draw",398,G__G__Geom1_174_6_0,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_174_7_0,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_174_8_0,121,-1,-1,0,0,1,1,0,"","*MENU*",(void*)NULL,0);
   G__memfunc_setup("FillIdArray",1075,G__G__Geom1_174_9_0,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_174_0_1,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_174_1_1,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_174_2_1,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_174_3_1,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_174_4_1,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_174_5_1,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_174_6_1,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_174_7_1,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_174_8_1,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_174_9_1,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_174_0_2,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_174_1_2,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_174_2_2,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_174_3_2,85,G__get_linked_tagnum(&G__G__Geom1LN_TGeoVolume),-1,0,0,1,1,8,"",(char*)NULL,(void*)NULL,0);
   G__memfunc_setup("GetOptimalVoxels",1655,G__G__Geom1_174_4_2,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_174_5_2,121,-1,-1,0,0,1,1,8,"","*MENU*",(void*)NULL,0);
   G__memfunc_setup("IsFolder",792,G__G__Geom1_174_6_2,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_174_7_2,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_174_8_2,103,-1,G__defined_typename("Bool_t"),0,0,1,1,8,"","*MENU*",(void*)NULL,0);
   G__memfunc_setup("IsOverlapping",1347,G__G__Geom1_174_9_2,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_174_0_3,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_174_1_3,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_174_2_3,103,-1,G__defined_typename("Bool_t"),0,0,1,1,8,"",(char*)NULL,(void*)NULL,0);
   G__memfunc_setup("MakeCopyNode",1183,G__G__Geom1_174_3_3,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_174_4_3,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_174_5_3,121,-1,-1,0,1,1,1,0,"u 'basic_ofstream<char,char_traits<char> >' 'ofstream' 1 - out",(char*)NULL,(void*)NULL,0);
   G__memfunc_setup("SetCurrentPoint",1561,G__G__Geom1_174_6_3,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_174_7_3,121,-1,-1,0,1,1,1,0,"U 'TGeoVolume' - 10 - volume",(char*)NULL,(void*)NULL,0);
   G__memfunc_setup("SetNumber",917,G__G__Geom1_174_8_3,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_174_9_3,121,-1,-1,0,0,1,1,0,"",(char*)NULL,(void*)NULL,0);
   G__memfunc_setup("SetVirtual",1043,G__G__Geom1_174_0_4,121,-1,-1,0,0,1,1,0,"",(char*)NULL,(void*)NULL,0);
   G__memfunc_setup("SetVisibility",1364,G__G__Geom1_174_1_4,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_174_2_4,121,-1,-1,0,0,1,1,0,"","*MENU*",(void*)NULL,0);
   G__memfunc_setup("SetAllInvisible",1514,G__G__Geom1_174_3_4,121,-1,-1,0,0,1,1,0,"","*MENU*",(void*)NULL,0);
   G__memfunc_setup("SetMotherVolume",1555,G__G__Geom1_174_4_4,121,-1,-1,0,1,1,1,0,"U 'TGeoVolume' - 10 - mother",(char*)NULL,(void*)NULL,0);
   G__memfunc_setup("SetOverlaps",1144,G__G__Geom1_174_5_4,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_174_6_4,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_174_7_4,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_174_8_4,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_174_9_4,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__G__Geom1_174_0_5,121,-1,-1,0,1,1,1,8,"C - 'Option_t' 10 \"\" option",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("Paint",508,G__G__Geom1_174_1_5,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_174_2_5,121,-1,-1,0,0,1,1,8,"","*MENU*",(void*)NULL,0);
   G__memfunc_setup("PrintOverlaps",1369,G__G__Geom1_174_3_5,121,-1,-1,0,0,1,1,8,"","*MENU*",(void*)NULL,0);
   G__memfunc_setup("VisibleDaughters",1653,G__G__Geom1_174_4_5,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_174_5_5,85,G__get_linked_tagnum(&G__G__Geom1LN_TClass),-1,0,0,3,1,0,"",(char*)NULL,(void*)(TClass* (*)())(&TGeoNode::Class),0);
   G__memfunc_setup("Class_Name",982,G__G__Geom1_174_6_5,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)(const char* (*)())(&TGeoNode::Class_Name),0);
   G__memfunc_setup("Class_Version",1339,G__G__Geom1_174_7_5,115,-1,G__defined_typename("Version_t"),0,0,3,1,0,"",(char*)NULL,(void*)(Version_t (*)())(&TGeoNode::Class_Version),0);
   G__memfunc_setup("Dictionary",1046,G__G__Geom1_174_8_5,121,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)(void (*)())(&TGeoNode::Dictionary),0);
   G__memfunc_setup("IsA",253,G__G__Geom1_174_9_5,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_174_0_6,121,-1,-1,0,2,1,1,0,
"u 'TMemberInspector' - 1 - insp C - - 0 - parent",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("Streamer",835,G__G__Geom1_174_1_6,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_174_2_6,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_174_3_6,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)(const char* (*)())(&TGeoNode::DeclFileName),0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Geom1_174_4_6,105,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)(int (*)())(&TGeoNode::ImplFileLine),0);
   G__memfunc_setup("ImplFileName",1171,G__G__Geom1_174_5_6,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)(const char* (*)())(&TGeoNode::ImplFileName),0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Geom1_174_6_6,105,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)(int (*)())(&TGeoNode::DeclFileLine),0);
   // automatic destructor
   G__memfunc_setup("~TGeoNode",883,G__G__Geom1_174_7_6,(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_174_8_6,(int)('u'),G__get_linked_tagnum(&G__G__Geom1LN_TGeoNode),-1,1,1,1,1,0,"u 'TGeoNode' - 11 - -",(char*)NULL,(void*)NULL,0);
   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__G__Geom1_175_1_0,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_175_2_0,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("BuildVoxelLimits",1648,G__G__Geom1_175_3_0,121,-1,-1,0,0,1,1,0,"",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("CreateCheckList",1486,G__G__Geom1_175_4_0,121,-1,-1,0,0,1,1,0,"",(char*)NULL,(void*)NULL,0);
   G__memfunc_setup("DaughterToMother",1638,G__G__Geom1_175_5_0,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_175_6_0,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_175_7_0,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_175_8_0,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("GetExtraX",892,G__G__Geom1_175_9_0,73,-1,G__defined_typename("Int_t"),0,3,1,1,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__G__Geom1_175_0_1,73,-1,G__defined_typename("Int_t"),0,3,1,1,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__G__Geom1_175_1_1,73,-1,G__defined_typename("Int_t"),0,3,1,1,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__G__Geom1_175_2_1,103,-1,G__defined_typename("Bool_t"),0,1,1,1,0,"D - 'Double_t' 0 - point",(char*)NULL,(void*)NULL,0);
   G__memfunc_setup("GetPriority",1154,G__G__Geom1_175_3_1,105,-1,G__defined_typename("Int_t"),0,1,1,1,8,"i - 'Int_t' 0 - iaxis",(char*)NULL,(void*)NULL,0);
   G__memfunc_setup("GetNcandidates",1406,G__G__Geom1_175_4_1,105,-1,G__defined_typename("Int_t"),0,0,1,1,8,"",(char*)NULL,(void*)NULL,0);
   G__memfunc_setup("GetNextCandidates",1711,G__G__Geom1_175_5_1,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("GetNextVoxel",1229,G__G__Geom1_175_6_1,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("GetValidExtra",1300,G__G__Geom1_175_7_1,73,-1,G__defined_typename("Int_t"),0,2,1,1,0,
"I - 'Int_t' 0 - list i - 'Int_t' 1 - ncheck",(char*)NULL,(void*)NULL,0);
   G__memfunc_setup("GetValidExtra",1300,G__G__Geom1_175_8_1,73,-1,G__defined_typename("Int_t"),0,4,1,1,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__G__Geom1_175_9_1,73,-1,G__defined_typename("Int_t"),0,6,1,1,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__G__Geom1_175_0_2,73,-1,G__defined_typename("Int_t"),0,4,1,1,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,1);
   G__memfunc_setup("FindOverlaps",1229,G__G__Geom1_175_1_2,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_175_2_2,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_175_3_2,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_175_4_2,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__G__Geom1_175_5_2,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_175_6_2,121,-1,-1,0,1,1,1,8,"D - 'Double_t' 0 - point",(char*)NULL,(void*)NULL,0);
   G__memfunc_setup("Intersect",945,G__G__Geom1_175_7_2,103,-1,G__defined_typename("Bool_t"),0,4,1,1,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__G__Geom1_175_8_2,103,-1,G__defined_typename("Bool_t"),0,6,1,1,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__G__Geom1_175_9_2,103,-1,G__defined_typename("Bool_t"),0,8,1,1,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__G__Geom1_175_0_3,103,-1,G__defined_typename("Bool_t"),0,2,1,1,0,
"i - 'Int_t' 0 - n1 B - 'UChar_t' 0 - array1",(char*)NULL,(void*)NULL,0);
   G__memfunc_setup("IntersectAndStore",1745,G__G__Geom1_175_1_3,103,-1,G__defined_typename("Bool_t"),0,4,1,1,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__G__Geom1_175_2_3,103,-1,G__defined_typename("Bool_t"),0,6,1,1,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("SetInvalid",1011,G__G__Geom1_175_3_3,121,-1,-1,0,1,1,1,0,"g - 'Bool_t' 0 kTRUE flag",(char*)NULL,(void*)NULL,0);
   G__memfunc_setup("SortAll",705,G__G__Geom1_175_4_3,121,-1,-1,0,1,1,1,0,"C - 'Option_t' 10 \"\" option",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("SortCrossedVoxels",1788,G__G__Geom1_175_5_3,121,-1,-1,0,2,1,1,0,
"D - 'Double_t' 0 - point D - 'Double_t' 0 - dir",(char*)NULL,(void*)NULL,0);
   G__memfunc_setup("Union",521,G__G__Geom1_175_6_3,103,-1,G__defined_typename("Bool_t"),0,2,1,1,0,
"i - 'Int_t' 0 - n1 B - 'UChar_t' 0 - array1",(char*)NULL,(void*)NULL,0);
   G__memfunc_setup("Union",521,G__G__Geom1_175_7_3,103,-1,G__defined_typename("Bool_t"),0,4,1,1,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__G__Geom1_175_8_3,103,-1,G__defined_typename("Bool_t"),0,6,1,1,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("Voxelize",854,G__G__Geom1_175_9_3,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_175_0_4,85,G__get_linked_tagnum(&G__G__Geom1LN_TClass),-1,0,0,3,1,0,"",(char*)NULL,(void*)(TClass* (*)())(&TGeoVoxelFinder::Class),0);
   G__memfunc_setup("Class_Name",982,G__G__Geom1_175_1_4,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)(const char* (*)())(&TGeoVoxelFinder::Class_Name),0);
   G__memfunc_setup("Class_Version",1339,G__G__Geom1_175_2_4,115,-1,G__defined_typename("Version_t"),0,0,3,1,0,"",(char*)NULL,(void*)(Version_t (*)())(&TGeoVoxelFinder::Class_Version),0);
   G__memfunc_setup("Dictionary",1046,G__G__Geom1_175_3_4,121,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)(void (*)())(&TGeoVoxelFinder::Dictionary),0);
   G__memfunc_setup("IsA",253,G__G__Geom1_175_4_4,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_175_5_4,121,-1,-1,0,2,1,1,0,
"u 'TMemberInspector' - 1 - insp C - - 0 - parent",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("Streamer",835,G__G__Geom1_175_6_4,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_175_7_4,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_175_8_4,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)(const char* (*)())(&TGeoVoxelFinder::DeclFileName),0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Geom1_175_9_4,105,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)(int (*)())(&TGeoVoxelFinder::ImplFileLine),0);
   G__memfunc_setup("ImplFileName",1171,G__G__Geom1_175_0_5,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)(const char* (*)())(&TGeoVoxelFinder::ImplFileName),0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Geom1_175_1_5,105,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)(int (*)())(&TGeoVoxelFinder::DeclFileLine),0);
   // automatic copy constructor
   G__memfunc_setup("TGeoVoxelFinder",1493,G__G__Geom1_175_2_5,(int)('i'),G__get_linked_tagnum(&G__G__Geom1LN_TGeoVoxelFinder),-1,0,1,1,1,0,"u 'TGeoVoxelFinder' - 11 - -",(char*)NULL,(void*)NULL,0);
   // automatic destructor
   G__memfunc_setup("~TGeoVoxelFinder",1619,G__G__Geom1_175_3_5,(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_175_4_5,(int)('u'),G__get_linked_tagnum(&G__G__Geom1LN_TGeoVoxelFinder),-1,1,1,1,1,0,"u 'TGeoVoxelFinder' - 11 - -",(char*)NULL,(void*)NULL,0);
   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("BuildCache",964,(G__InterfaceMethod)NULL,121,-1,-1,0,2,1,4,0,
"g - 'Bool_t' 0 kFALSE dummy g - 'Bool_t' 0 kFALSE nodeid",(char*)NULL,(void*)NULL,0);
   G__memfunc_setup("BuildIdArray",1180,(G__InterfaceMethod)NULL,121,-1,-1,0,0,1,4,0,"",(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,4,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,4,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("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("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("SafetyOverlaps",1464,(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_177_0_1,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_177_1_1,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_177_2_1,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_177_3_1,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_177_4_1,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_177_5_1,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_177_6_1,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("AddVolume",897,G__G__Geom1_177_7_1,105,-1,G__defined_typename("Int_t"),0,1,1,1,0,"U 'TGeoVolume' - 0 - volume",(char*)NULL,(void*)NULL,0);
   G__memfunc_setup("ClearOverlaps",1331,G__G__Geom1_177_8_1,121,-1,-1,0,0,1,1,0,"",(char*)NULL,(void*)NULL,0);
   G__memfunc_setup("RegisterMatrix",1466,G__G__Geom1_177_9_1,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_177_0_2,121,-1,-1,0,0,1,1,0,"",(char*)NULL,(void*)NULL,0);
   G__memfunc_setup("Browse",626,G__G__Geom1_177_1_2,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_2_2,103,-1,G__defined_typename("Bool_t"),0,1,1,1,0,"C - - 10 \"\" path","*MENU*",(void*)NULL,1);
   G__memfunc_setup("CdNode",557,G__G__Geom1_177_3_2,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_177_4_2,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_177_5_2,121,-1,-1,0,0,1,1,0,"",(char*)NULL,(void*)NULL,0);
   G__memfunc_setup("CdTop",474,G__G__Geom1_177_6_2,121,-1,-1,0,0,1,1,0,"",(char*)NULL,(void*)NULL,0);
   G__memfunc_setup("GetBranchNames",1378,G__G__Geom1_177_7_2,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_177_8_2,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_177_9_2,121,-1,-1,0,1,1,1,8,"I - 'Int_t' 0 - isonly",(char*)NULL,(void*)NULL,0);
   G__memfunc_setup("GetPdgName",956,G__G__Geom1_177_0_3,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_177_1_3,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__G__Geom1_177_2_3,103,-1,G__defined_typename("Bool_t"),0,0,1,1,8,"",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("BombTranslation",1551,G__G__Geom1_177_3_3,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_177_4_3,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_177_5_3,121,-1,-1,0,0,1,1,0,"","*MENU*",(void*)NULL,0);
   G__memfunc_setup("DefaultAngles",1311,G__G__Geom1_177_6_3,121,-1,-1,0,0,1,1,0,"","*MENU*",(void*)NULL,0);
   G__memfunc_setup("DefaultColors",1335,G__G__Geom1_177_7_3,121,-1,-1,0,0,1,1,0,"","*MENU*",(void*)NULL,0);
   G__memfunc_setup("GetClippingShape",1607,G__G__Geom1_177_8_3,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_177_9_3,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_177_0_4,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_177_1_4,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_177_2_4,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_177_3_4,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_177_4_4,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_177_5_4,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_177_6_4,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_177_7_4,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_177_8_4,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_177_9_4,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_177_0_5,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_177_1_5,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_177_2_5,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_177_3_5,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_177_4_5,121,-1,-1,0,0,1,1,8,"",(char*)NULL,(void*)NULL,0);
   G__memfunc_setup("OptimizeVoxels",1490,G__G__Geom1_177_5_5,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_177_6_5,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_177_7_5,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_177_8_5,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_177_9_5,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_177_0_6,121,-1,-1,0,1,1,1,0,"i - 'Int_t' 0 - nseg","*MENU*",(void*)NULL,0);
   G__memfunc_setup("SetBombFactors",1406,G__G__Geom1_177_1_6,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_177_2_6,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_177_3_6,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_177_4_6,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_177_5_6,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_177_6_6,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_177_7_6,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_177_8_6,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_177_9_6,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_177_0_7,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_177_1_7,121,-1,-1,0,0,1,1,0,"","*MENU*",(void*)NULL,0);
   G__memfunc_setup("SetMaxVisNodes",1405,G__G__Geom1_177_2_7,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_177_3_7,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("CheckGeometry",1322,G__G__Geom1_177_4_7,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_177_5_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("CheckPoint",1000,G__G__Geom1_177_6_7,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("DrawCurrentPoint",1659,G__G__Geom1_177_7_7,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_177_8_7,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_177_9_7,121,-1,-1,0,1,1,1,0,"C - - 10 - pname",(char*)NULL,(void*)NULL,0);
   G__memfunc_setup("GetParticleName",1493,G__G__Geom1_177_0_8,67,-1,-1,0,0,1,1,9,"",(char*)NULL,(void*)NULL,0);
   G__memfunc_setup("DrawPath",795,G__G__Geom1_177_1_8,121,-1,-1,0,1,1,1,0,"C - - 10 - path",(char*)NULL,(void*)NULL,0);
   G__memfunc_setup("PrintOverlaps",1369,G__G__Geom1_177_2_8,121,-1,-1,0,0,1,1,8,"","*MENU*",(void*)NULL,0);
   G__memfunc_setup("RandomPoints",1246,G__G__Geom1_177_3_8,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_177_4_8,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_177_5_8,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("Test",416,G__G__Geom1_177_6_8,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_177_7_8,121,-1,-1,0,1,1,1,0,"C - - 10 \"\" path","*MENU*",(void*)NULL,0);
   G__memfunc_setup("Weight",616,G__G__Geom1_177_8_8,100,-1,G__defined_typename("Double_t"),0,2,1,1,0,
"d - 'Double_t' 0 0.01 precision C - 'Option_t' 10 \"v\" option","*MENU*",(void*)NULL,0);
   G__memfunc_setup("Division",837,G__G__Geom1_177_9_8,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_177_0_9,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_177_1_9,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_177_2_9,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_177_3_9,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_177_4_9,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_177_5_9,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_177_6_9,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_177_7_9,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_177_8_9,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_177_9_9,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_177_0_10,121,-1,-1,0,0,1,1,0,"",(char*)NULL,(void*)NULL,0);
   G__memfunc_setup("CloseGeometry",1346,G__G__Geom1_177_1_10,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_177_2_10,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_177_3_10,85,G__get_linked_tagnum(&G__G__Geom1LN_TGeoVolume),-1,0,4,1,1,0,
"C - - 10 - name U 'TGeoMedium' - 10 - 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_177_4_10,85,G__get_linked_tagnum(&G__G__Geom1LN_TGeoVolume),-1,0,5,1,1,0,
"C - - 10 - name U 'TGeoMedium' - 10 - 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_177_5_10,85,G__get_linked_tagnum(&G__G__Geom1LN_TGeoVolume),-1,0,7,1,1,0,
"C - - 10 - name U 'TGeoMedium' - 10 - 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_177_6_10,85,G__get_linked_tagnum(&G__G__Geom1LN_TGeoVolume),-1,0,9,1,1,0,
"C - - 10 - name U 'TGeoMedium' - 10 - 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_177_7_10,85,G__get_linked_tagnum(&G__G__Geom1LN_TGeoVolume),-1,0,13,1,1,0,
"C - - 10 - name U 'TGeoMedium' - 10 - 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_177_8_10,85,G__get_linked_tagnum(&G__G__Geom1LN_TGeoVolume),-1,0,5,1,1,0,
"C - - 10 - name U 'TGeoMedium' - 10 - 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_177_9_10,85,G__get_linked_tagnum(&G__G__Geom1LN_TGeoVolume),-1,0,14,1,1,0,
"C - - 10 - name U 'TGeoMedium' - 10 - 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_177_0_11,85,G__get_linked_tagnum(&G__G__Geom1LN_TGeoVolume),-1,0,8,1,1,0,
"C - - 10 - name U 'TGeoMedium' - 10 - 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_177_1_11,85,G__get_linked_tagnum(&G__G__Geom1LN_TGeoVolume),-1,0,5,1,1,0,
"C - - 10 - name U 'TGeoMedium' - 10 - 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_177_2_11,85,G__get_linked_tagnum(&G__G__Geom1LN_TGeoVolume),-1,0,5,1,1,0,
"C - - 10 - name U 'TGeoMedium' - 10 - 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_177_3_11,85,G__get_linked_tagnum(&G__G__Geom1LN_TGeoVolume),-1,0,7,1,1,0,
"C - - 10 - name U 'TGeoMedium' - 10 - 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_177_4_11,85,G__get_linked_tagnum(&G__G__Geom1LN_TGeoVolume),-1,0,6,1,1,0,
"C - - 10 - name U 'TGeoMedium' - 10 - 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_177_5_11,85,G__get_linked_tagnum(&G__G__Geom1LN_TGeoVolume),-1,0,8,1,1,0,
"C - - 10 - name U 'TGeoMedium' - 10 - 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_177_6_11,85,G__get_linked_tagnum(&G__G__Geom1LN_TGeoVolume),-1,0,7,1,1,0,
"C - - 10 - name U 'TGeoMedium' - 10 - 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_177_7_11,85,G__get_linked_tagnum(&G__G__Geom1LN_TGeoVolume),-1,0,13,1,1,0,
"C - - 10 - name U 'TGeoMedium' - 10 - 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_177_8_11,85,G__get_linked_tagnum(&G__G__Geom1LN_TGeoVolume),-1,0,6,1,1,0,
"C - - 10 - name U 'TGeoMedium' - 10 - 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_177_9_11,85,G__get_linked_tagnum(&G__G__Geom1LN_TGeoVolume),-1,0,7,1,1,0,
"C - - 10 - name U 'TGeoMedium' - 10 - 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_177_0_12,85,G__get_linked_tagnum(&G__G__Geom1LN_TGeoVolume),-1,0,5,1,1,0,
"C - - 10 - name U 'TGeoMedium' - 10 - 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_177_1_12,85,G__get_linked_tagnum(&G__G__Geom1LN_TGeoVolume),-1,0,7,1,1,0,
"C - - 10 - name U 'TGeoMedium' - 10 - 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_177_2_12,85,G__get_linked_tagnum(&G__G__Geom1LN_TGeoVolume),-1,0,3,1,1,0,
"C - - 10 - name U 'TGeoMedium' - 10 - medium "
"i - 'Int_t' 0 - nz",(char*)NULL,(void*)NULL,0);
   G__memfunc_setup("MakePhysicalNode",1601,G__G__Geom1_177_3_12,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_177_4_12,121,-1,-1,0,1,1,1,0,"g - 'Bool_t' 0 kFALSE mustdelete",(char*)NULL,(void*)NULL,0);
   G__memfunc_setup("MakeTrack",883,G__G__Geom1_177_5_12,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_177_6_12,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_177_7_12,85,G__get_linked_tagnum(&G__G__Geom1LN_TGeoVolumeMulti),-1,0,2,1,1,0,
"C - - 10 - name U 'TGeoMedium' - 10 - medium",(char*)NULL,(void*)NULL,0);
   G__memfunc_setup("SetTopVolume",1239,G__G__Geom1_177_8_12,121,-1,-1,0,1,1,1,0,"U 'TGeoVolume' - 0 - vol",(char*)NULL,(void*)NULL,0);
   G__memfunc_setup("FindNextBoundary",1636,G__G__Geom1_177_9_12,85,G__get_linked_tagnum(&G__G__Geom1LN_TGeoNode),-1,0,2,1,1,0,
"d - 'Double_t' 0 1e30 stepmax C - - 10 \"\" path",(char*)NULL,(void*)NULL,0);
   G__memfunc_setup("FindNextDaughterBoundary",2456,G__G__Geom1_177_0_13,85,G__get_linked_tagnum(&G__G__Geom1LN_TGeoNode),-1,0,3,1,1,0,
"D - 'Double_t' 0 - point D - 'Double_t' 0 - dir "
"g - 'Bool_t' 0 kFALSE compmatrix",(char*)NULL,(void*)NULL,0);
   G__memfunc_setup("FindNode",775,G__G__Geom1_177_1_13,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_177_2_13,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_177_3_13,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_177_4_13,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_177_5_13,85,G__get_linked_tagnum(&G__G__Geom1LN_TGeoNode),-1,0,2,1,1,0,
"D - 'Double_t' 0 - point D - 'Double_t' 0 - dir",(char*)NULL,(void*)NULL,0);
   G__memfunc_setup("InitTrack",905,G__G__Geom1_177_6_13,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("Safety",620,G__G__Geom1_177_7_13,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_177_8_13,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_177_9_13,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("SetCurrentTrack",1540,G__G__Geom1_177_0_14,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_177_1_14,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_177_2_14,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_177_3_14,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_177_4_14,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_177_5_14,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_177_6_14,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_177_7_14,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_177_8_14,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_177_9_14,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_177_0_15,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_177_1_15,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_177_2_15,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_177_3_15,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_177_4_15,100,-1,G__defined_typename("Double_t"),0,0,1,1,8,"",(char*)NULL,(void*)NULL,0);
   G__memfunc_setup("IsAnimatingTracks",1724,G__G__Geom1_177_5_15,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_177_6_15,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_177_7_15,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_177_8_15,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_177_9_15,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_177_0_16,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_177_1_16,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_177_2_16,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_177_3_16,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_177_4_16,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_177_5_16,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_177_6_16,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_177_7_16,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_177_8_16,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_177_9_16,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_177_0_17,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_177_1_17,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_177_2_17,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_177_3_17,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_177_4_17,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_177_5_17,121,-1,-1,0,1,1,1,0,"g - 'Bool_t' 0 kTRUE flag",(char*)NULL,(void*)NULL,0);
   G__memfunc_setup("UpdateCurrentPosition",2203,G__G__Geom1_177_6_17,121,-1,-1,0,1,1,1,0,"D - 'Double_t' 0 - nextpoint",(char*)NULL,(void*)NULL,0);
   G__memfunc_setup("CleanGarbage",1164,G__G__Geom1_177_7_17,121,-1,-1,0,0,1,1,0,"",(char*)NULL,(void*)NULL,0);
   G__memfunc_setup("ClearShape",984,G__G__Geom1_177_8_17,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_177_9_17,121,-1,-1,0,0,1,1,0,"",(char*)NULL,(void*)NULL,0);
   G__memfunc_setup("RemoveMaterial",1437,G__G__Geom1_177_0_18,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_177_1_18,121,-1,-1,0,0,1,1,0,"",(char*)NULL,(void*)NULL,0);
   G__memfunc_setup("CountNodes",1026,G__G__Geom1_177_2_18,105,-1,G__defined_typename("Int_t"),0,3,1,1,0,
"U 'TGeoVolume' - 10 0 vol i - 'Int_t' 0 1000 nlevels "
"i - 'Int_t' 0 0 option",(char*)NULL,(void*)NULL,0);
   G__memfunc_setup("Parse",507,G__G__Geom1_177_3_18,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*)(Int_t (*)(const char*,TString&,TString&,TString&))(&TGeoManager::Parse),0);
   G__memfunc_setup("GetBits",690,G__G__Geom1_177_4_18,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_177_5_18,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_177_6_18,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_177_7_18,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_177_8_18,121,-1,-1,0,0,1,1,0,"",(char*)NULL,(void*)NULL,0);
   G__memfunc_setup("Export",642,G__G__Geom1_177_9_18,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("Import",635,G__G__Geom1_177_0_19,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*)(TGeoManager* (*)(const char*,const char*,Option_t*))(&TGeoManager::Import),0);
   G__memfunc_setup("IsStreamingVoxels",1767,G__G__Geom1_177_1_19,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_177_2_19,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_177_3_19,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_177_4_19,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_177_5_19,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_177_6_19,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_177_7_19,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_177_8_19,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_177_9_19,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_177_0_20,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_177_1_20,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_177_2_20,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_177_3_20,85,G__get_linked_tagnum(&G__G__Geom1LN_TGeoElementTable),-1,0,0,1,1,8,"",(char*)NULL,(void*)NULL,0);
   G__memfunc_setup("GetNode",678,G__G__Geom1_177_4_20,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_177_5_20,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_177_6_20,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_177_7_20,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("GetHMatrix",989,G__G__Geom1_177_8_20,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_177_9_20,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_177_0_21,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_177_1_21,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_177_2_21,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_177_3_21,68,-1,G__defined_typename("Double_t"),0,0,1,1,8,"",(char*)NULL,(void*)NULL,0);
   G__memfunc_setup("GetCurrentDirection",1956,G__G__Geom1_177_4_21,68,-1,G__defined_typename("Double_t"),0,0,1,1,8,"",(char*)NULL,(void*)NULL,0);
   G__memfunc_setup("GetCurrentVolume",1659,G__G__Geom1_177_5_21,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_177_6_21,68,-1,G__defined_typename("Double_t"),0,0,1,1,8,"",(char*)NULL,(void*)NULL,0);
   G__memfunc_setup("GetCldir",782,G__G__Geom1_177_7_21,68,-1,G__defined_typename("Double_t"),0,0,1,1,8,"",(char*)NULL,(void*)NULL,0);
   G__memfunc_setup("GetNormal",905,G__G__Geom1_177_8_21,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_177_9_21,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_177_0_22,67,-1,-1,0,0,1,1,9,"",(char*)NULL,(void*)NULL,0);
   G__memfunc_setup("GetStackLevel",1294,G__G__Geom1_177_1_22,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_177_2_22,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_177_3_22,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_177_4_22,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_177_5_22,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_177_6_22,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_177_7_22,121,-1,-1,0,3,1,1,0,
"d - 'Double_t' 0 - x d - 'Double_t' 0 - y "
"d - 'Double_t' 0 - z",(char*)NULL,(void*)NULL,0);
   G__memfunc_setup("SetLastPoint",1226,G__G__Geom1_177_8_22,121,-1,-1,0,3,1,1,0,
"d - 'Double_t' 0 - x d - 'Double_t' 0 - y "
"d - 'Double_t' 0 - z",(char*)NULL,(void*)NULL,0);
   G__memfunc_setup("SetCurrentDirection",1968,G__G__Geom1_177_9_22,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_177_0_23,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_177_1_23,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_177_2_23,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_177_3_23,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_177_4_23,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_177_5_23,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_177_6_23,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_177_7_23,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_177_8_23,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_177_9_23,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_177_0_24,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("GetMaterial",1103,G__G__Geom1_177_1_24,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_177_2_24,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_177_3_24,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_177_4_24,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_177_5_24,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_177_6_24,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_177_7_24,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_177_8_24,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_177_9_24,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_177_0_25,85,G__get_linked_tagnum(&G__G__Geom1LN_TGeoNodeCache),-1,0,0,1,1,8,"",(char*)NULL,(void*)NULL,0);
   G__memfunc_setup("SetCache",768,G__G__Geom1_177_1_25,121,-1,-1,0,1,1,1,0,"U 'TGeoNodeCache' - 10 - cache",(char*)NULL,(void*)NULL,0);
   G__memfunc_setup("SetAnimateTracks",1619,G__G__Geom1_177_2_25,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_177_3_25,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_177_4_25,121,-1,-1,0,0,1,1,0,"",(char*)NULL,(void*)NULL,0);
   G__memfunc_setup("PushPath",813,G__G__Geom1_177_5_25,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_177_6_25,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_177_7_25,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_177_8_25,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_177_9_25,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_177_0_26,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_177_1_26,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_177_2_26,85,G__get_linked_tagnum(&G__G__Geom1LN_TClass),-1,0,0,3,1,0,"",(char*)NULL,(void*)(TClass* (*)())(&TGeoManager::Class),0);
   G__memfunc_setup("Class_Name",982,G__G__Geom1_177_3_26,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)(const char* (*)())(&TGeoManager::Class_Name),0);
   G__memfunc_setup("Class_Version",1339,G__G__Geom1_177_4_26,115,-1,G__defined_typename("Version_t"),0,0,3,1,0,"",(char*)NULL,(void*)(Version_t (*)())(&TGeoManager::Class_Version),0);
   G__memfunc_setup("Dictionary",1046,G__G__Geom1_177_5_26,121,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)(void (*)())(&TGeoManager::Dictionary),0);
   G__memfunc_setup("IsA",253,G__G__Geom1_177_6_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_177_7_26,121,-1,-1,0,2,1,1,0,
"u 'TMemberInspector' - 1 - insp C - - 0 - parent",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("Streamer",835,G__G__Geom1_177_8_26,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_9_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_177_0_27,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)(const char* (*)())(&TGeoManager::DeclFileName),0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Geom1_177_1_27,105,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)(int (*)())(&TGeoManager::ImplFileLine),0);
   G__memfunc_setup("ImplFileName",1171,G__G__Geom1_177_2_27,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)(const char* (*)())(&TGeoManager::ImplFileName),0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Geom1_177_3_27,105,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)(int (*)())(&TGeoManager::DeclFileLine),0);
   // automatic copy constructor
   G__memfunc_setup("TGeoManager",1066,G__G__Geom1_177_4_27,(int)('i'),G__get_linked_tagnum(&G__G__Geom1LN_TGeoManager),-1,0,1,1,1,0,"u 'TGeoManager' - 11 - -",(char*)NULL,(void*)NULL,0);
   // automatic destructor
   G__memfunc_setup("~TGeoManager",1192,G__G__Geom1_177_5_27,(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_177_6_27,(int)('u'),G__get_linked_tagnum(&G__G__Geom1LN_TGeoManager),-1,1,1,1,1,0,"u 'TGeoManager' - 11 - -",(char*)NULL,(void*)NULL,0);
   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__G__Geom1_179_1_0,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_179_2_0,105,G__get_linked_tagnum(&G__G__Geom1LN_TGeoVolumeMulti),-1,0,2,1,1,0,
"C - - 10 - name U 'TGeoMedium' - 10 0 med",(char*)NULL,(void*)NULL,0);
   G__memfunc_setup("AddVolume",897,G__G__Geom1_179_3_0,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_179_4_0,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__G__Geom1_179_5_0,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__G__Geom1_179_6_0,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__G__Geom1_179_7_0,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_179_8_0,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_179_9_0,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_179_0_1,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_179_1_1,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_179_2_1,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_179_3_1,100,-1,G__defined_typename("Double_t"),0,0,1,1,8,"",(char*)NULL,(void*)NULL,0);
   G__memfunc_setup("IsVolumeMulti",1343,G__G__Geom1_179_4_1,103,-1,G__defined_typename("Bool_t"),0,0,1,1,8,"",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("MakeCopyVolume",1425,G__G__Geom1_179_5_1,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__G__Geom1_179_6_1,121,-1,-1,0,1,1,1,0,"s - 'Color_t' 0 - lcolor",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("SetLineStyle",1221,G__G__Geom1_179_7_1,121,-1,-1,0,1,1,1,0,"s - 'Style_t' 0 - lstyle",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("SetLineWidth",1204,G__G__Geom1_179_8_1,121,-1,-1,0,1,1,1,0,"s - 'Width_t' 0 - lwidth",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("SetMedium",909,G__G__Geom1_179_9_1,121,-1,-1,0,1,1,1,0,"U 'TGeoMedium' - 10 - medium",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("SetVisibility",1364,G__G__Geom1_179_0_2,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_179_1_2,85,G__get_linked_tagnum(&G__G__Geom1LN_TClass),-1,0,0,3,1,0,"",(char*)NULL,(void*)(TClass* (*)())(&TGeoVolumeMulti::Class),0);
   G__memfunc_setup("Class_Name",982,G__G__Geom1_179_2_2,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)(const char* (*)())(&TGeoVolumeMulti::Class_Name),0);
   G__memfunc_setup("Class_Version",1339,G__G__Geom1_179_3_2,115,-1,G__defined_typename("Version_t"),0,0,3,1,0,"",(char*)NULL,(void*)(Version_t (*)())(&TGeoVolumeMulti::Class_Version),0);
   G__memfunc_setup("Dictionary",1046,G__G__Geom1_179_4_2,121,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)(void (*)())(&TGeoVolumeMulti::Dictionary),0);
   G__memfunc_setup("IsA",253,G__G__Geom1_179_5_2,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_179_6_2,121,-1,-1,0,2,1,1,0,
"u 'TMemberInspector' - 1 - insp C - - 0 - parent",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("Streamer",835,G__G__Geom1_179_7_2,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_8_2,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_9_2,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)(const char* (*)())(&TGeoVolumeMulti::DeclFileName),0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Geom1_179_0_3,105,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)(int (*)())(&TGeoVolumeMulti::ImplFileLine),0);
   G__memfunc_setup("ImplFileName",1171,G__G__Geom1_179_1_3,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)(const char* (*)())(&TGeoVolumeMulti::ImplFileName),0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Geom1_179_2_3,105,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)(int (*)())(&TGeoVolumeMulti::DeclFileLine),0);
   // automatic copy constructor
   G__memfunc_setup("TGeoVolumeMulti",1522,G__G__Geom1_179_3_3,(int)('i'),G__get_linked_tagnum(&G__G__Geom1LN_TGeoVolumeMulti),-1,0,1,1,1,0,"u 'TGeoVolumeMulti' - 11 - -",(char*)NULL,(void*)NULL,0);
   // automatic destructor
   G__memfunc_setup("~TGeoVolumeMulti",1648,G__G__Geom1_179_4_3,(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_179_5_3,(int)('u'),G__get_linked_tagnum(&G__G__Geom1LN_TGeoVolumeMulti),-1,1,1,1,1,0,"u 'TGeoVolumeMulti' - 11 - -",(char*)NULL,(void*)NULL,0);
   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_180_1_0,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_180_2_0,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("IsAssembly",1020,G__G__Geom1_180_3_0,103,-1,G__defined_typename("Bool_t"),0,0,1,1,8,"",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("Class",502,G__G__Geom1_180_4_0,85,G__get_linked_tagnum(&G__G__Geom1LN_TClass),-1,0,0,3,1,0,"",(char*)NULL,(void*)(TClass* (*)())(&TGeoVolumeAssembly::Class),0);
   G__memfunc_setup("Class_Name",982,G__G__Geom1_180_5_0,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)(const char* (*)())(&TGeoVolumeAssembly::Class_Name),0);
   G__memfunc_setup("Class_Version",1339,G__G__Geom1_180_6_0,115,-1,G__defined_typename("Version_t"),0,0,3,1,0,"",(char*)NULL,(void*)(Version_t (*)())(&TGeoVolumeAssembly::Class_Version),0);
   G__memfunc_setup("Dictionary",1046,G__G__Geom1_180_7_0,121,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)(void (*)())(&TGeoVolumeAssembly::Dictionary),0);
   G__memfunc_setup("IsA",253,G__G__Geom1_180_8_0,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_180_9_0,121,-1,-1,0,2,1,1,0,
"u 'TMemberInspector' - 1 - insp C - - 0 - parent",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("Streamer",835,G__G__Geom1_180_0_1,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_1_1,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_2_1,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)(const char* (*)())(&TGeoVolumeAssembly::DeclFileName),0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Geom1_180_3_1,105,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)(int (*)())(&TGeoVolumeAssembly::ImplFileLine),0);
   G__memfunc_setup("ImplFileName",1171,G__G__Geom1_180_4_1,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)(const char* (*)())(&TGeoVolumeAssembly::ImplFileName),0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Geom1_180_5_1,105,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)(int (*)())(&TGeoVolumeAssembly::DeclFileLine),0);
   // automatic copy constructor
   G__memfunc_setup("TGeoVolumeAssembly",1831,G__G__Geom1_180_6_1,(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_180_7_1,(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_180_8_1,(int)('u'),G__get_linked_tagnum(&G__G__Geom1LN_TGeoVolumeAssembly),-1,1,1,1,1,0,"u 'TGeoVolumeAssembly' - 11 - -",(char*)NULL,(void*)NULL,0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGeoCylVoxels(void) {
   /* TGeoCylVoxels */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoCylVoxels));
   G__memfunc_setup("TGeoCylVoxels",1304,G__G__Geom1_195_1_0,105,G__get_linked_tagnum(&G__G__Geom1LN_TGeoCylVoxels),-1,0,0,1,1,0,"",(char*)NULL,(void*)NULL,0);
   G__memfunc_setup("TGeoCylVoxels",1304,G__G__Geom1_195_2_0,105,G__get_linked_tagnum(&G__G__Geom1LN_TGeoCylVoxels),-1,0,1,1,1,0,"U 'TGeoVolume' - 0 - vol",(char*)NULL,(void*)NULL,0);
   G__memfunc_setup("BuildVoxelLimits",1648,G__G__Geom1_195_3_0,121,-1,-1,0,0,1,1,0,"",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("Efficiency",1013,G__G__Geom1_195_4_0,100,-1,G__defined_typename("Double_t"),0,0,1,1,0,"",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("FindOverlaps",1229,G__G__Geom1_195_5_0,121,-1,-1,0,1,1,1,8,"i - 'Int_t' 0 - inode",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("GetCheckList",1178,G__G__Geom1_195_6_0,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("GetNextVoxel",1229,G__G__Geom1_195_7_0,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("IntersectIntervals",1897,G__G__Geom1_195_8_0,105,-1,G__defined_typename("Int_t"),0,4,1,1,8,
"d - 'Double_t' 0 - vox1 d - 'Double_t' 0 - vox2 "
"d - 'Double_t' 0 - phi1 d - 'Double_t' 0 - phi2",(char*)NULL,(void*)NULL,0);
   G__memfunc_setup("Print",525,G__G__Geom1_195_9_0,121,-1,-1,0,1,1,1,8,"C - 'Option_t' 10 \"\" option",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("SortAll",705,G__G__Geom1_195_0_1,121,-1,-1,0,1,1,1,0,"C - 'Option_t' 10 \"\" option",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("Voxelize",854,G__G__Geom1_195_1_1,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_195_2_1,85,G__get_linked_tagnum(&G__G__Geom1LN_TClass),-1,0,0,3,1,0,"",(char*)NULL,(void*)(TClass* (*)())(&TGeoCylVoxels::Class),0);
   G__memfunc_setup("Class_Name",982,G__G__Geom1_195_3_1,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)(const char* (*)())(&TGeoCylVoxels::Class_Name),0);
   G__memfunc_setup("Class_Version",1339,G__G__Geom1_195_4_1,115,-1,G__defined_typename("Version_t"),0,0,3,1,0,"",(char*)NULL,(void*)(Version_t (*)())(&TGeoCylVoxels::Class_Version),0);
   G__memfunc_setup("Dictionary",1046,G__G__Geom1_195_5_1,121,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)(void (*)())(&TGeoCylVoxels::Dictionary),0);
   G__memfunc_setup("IsA",253,G__G__Geom1_195_6_1,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_195_7_1,121,-1,-1,0,2,1,1,0,
"u 'TMemberInspector' - 1 - insp C - - 0 - parent",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("Streamer",835,G__G__Geom1_195_8_1,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_195_9_1,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_195_0_2,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)(const char* (*)())(&TGeoCylVoxels::DeclFileName),0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Geom1_195_1_2,105,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)(int (*)())(&TGeoCylVoxels::ImplFileLine),0);
   G__memfunc_setup("ImplFileName",1171,G__G__Geom1_195_2_2,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)(const char* (*)())(&TGeoCylVoxels::ImplFileName),0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Geom1_195_3_2,105,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)(int (*)())(&TGeoCylVoxels::DeclFileLine),0);
   // automatic copy constructor
   G__memfunc_setup("TGeoCylVoxels",1304,G__G__Geom1_195_4_2,(int)('i'),G__get_linked_tagnum(&G__G__Geom1LN_TGeoCylVoxels),-1,0,1,1,1,0,"u 'TGeoCylVoxels' - 11 - -",(char*)NULL,(void*)NULL,0);
   // automatic destructor
   G__memfunc_setup("~TGeoCylVoxels",1430,G__G__Geom1_195_5_2,(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_195_6_2,(int)('u'),G__get_linked_tagnum(&G__G__Geom1LN_TGeoCylVoxels),-1,1,1,1,1,0,"u 'TGeoCylVoxels' - 11 - -",(char*)NULL,(void*)NULL,0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGeoFullVoxels(void) {
   /* TGeoFullVoxels */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoFullVoxels));
   G__memfunc_setup("TGeoFullVoxels",1411,G__G__Geom1_196_1_0,105,G__get_linked_tagnum(&G__G__Geom1LN_TGeoFullVoxels),-1,0,0,1,1,0,"",(char*)NULL,(void*)NULL,0);
   G__memfunc_setup("TGeoFullVoxels",1411,G__G__Geom1_196_2_0,105,G__get_linked_tagnum(&G__G__Geom1LN_TGeoFullVoxels),-1,0,1,1,1,0,"U 'TGeoVolume' - 0 - vol",(char*)NULL,(void*)NULL,0);
   G__memfunc_setup("GetCheckList",1178,G__G__Geom1_196_3_0,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("GetVoxel",814,G__G__Geom1_196_4_0,66,-1,G__defined_typename("UChar_t"),0,3,1,1,8,
"i - 'Int_t' 0 - i i - 'Int_t' 0 - j "
"i - 'Int_t' 0 - k",(char*)NULL,(void*)NULL,0);
   G__memfunc_setup("GetVoxelCandidates",1822,G__G__Geom1_196_5_0,73,-1,G__defined_typename("Int_t"),0,4,1,1,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,1);
   G__memfunc_setup("Print",525,G__G__Geom1_196_6_0,121,-1,-1,0,1,1,1,8,"C - 'Option_t' 10 \"\" option",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("Voxelize",854,G__G__Geom1_196_7_0,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_196_8_0,85,G__get_linked_tagnum(&G__G__Geom1LN_TClass),-1,0,0,3,1,0,"",(char*)NULL,(void*)(TClass* (*)())(&TGeoFullVoxels::Class),0);
   G__memfunc_setup("Class_Name",982,G__G__Geom1_196_9_0,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)(const char* (*)())(&TGeoFullVoxels::Class_Name),0);
   G__memfunc_setup("Class_Version",1339,G__G__Geom1_196_0_1,115,-1,G__defined_typename("Version_t"),0,0,3,1,0,"",(char*)NULL,(void*)(Version_t (*)())(&TGeoFullVoxels::Class_Version),0);
   G__memfunc_setup("Dictionary",1046,G__G__Geom1_196_1_1,121,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)(void (*)())(&TGeoFullVoxels::Dictionary),0);
   G__memfunc_setup("IsA",253,G__G__Geom1_196_2_1,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_196_3_1,121,-1,-1,0,2,1,1,0,
"u 'TMemberInspector' - 1 - insp C - - 0 - parent",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("Streamer",835,G__G__Geom1_196_4_1,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_196_5_1,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_196_6_1,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)(const char* (*)())(&TGeoFullVoxels::DeclFileName),0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Geom1_196_7_1,105,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)(int (*)())(&TGeoFullVoxels::ImplFileLine),0);
   G__memfunc_setup("ImplFileName",1171,G__G__Geom1_196_8_1,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)(const char* (*)())(&TGeoFullVoxels::ImplFileName),0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Geom1_196_9_1,105,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)(int (*)())(&TGeoFullVoxels::DeclFileLine),0);
   // automatic copy constructor
   G__memfunc_setup("TGeoFullVoxels",1411,G__G__Geom1_196_0_2,(int)('i'),G__get_linked_tagnum(&G__G__Geom1LN_TGeoFullVoxels),-1,0,1,1,1,0,"u 'TGeoFullVoxels' - 11 - -",(char*)NULL,(void*)NULL,0);
   // automatic destructor
   G__memfunc_setup("~TGeoFullVoxels",1537,G__G__Geom1_196_1_2,(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_196_2_2,(int)('u'),G__get_linked_tagnum(&G__G__Geom1LN_TGeoFullVoxels),-1,1,1,1,1,0,"u 'TGeoFullVoxels' - 11 - -",(char*)NULL,(void*)NULL,0);
   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__G__Geom1_198_1_0,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_198_2_0,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__G__Geom1_198_3_0,105,-1,G__defined_typename("Int_t"),0,0,1,1,8,"",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("GetOptimalVoxels",1655,G__G__Geom1_198_4_0,105,-1,G__defined_typename("Int_t"),0,0,1,1,8,"",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("IsFolder",792,G__G__Geom1_198_5_0,103,-1,G__defined_typename("Bool_t"),0,0,1,1,8,"",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("GetMatrix",917,G__G__Geom1_198_6_0,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__G__Geom1_198_7_0,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_198_8_0,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_198_9_0,85,G__get_linked_tagnum(&G__G__Geom1LN_TClass),-1,0,0,3,1,0,"",(char*)NULL,(void*)(TClass* (*)())(&TGeoNodeMatrix::Class),0);
   G__memfunc_setup("Class_Name",982,G__G__Geom1_198_0_1,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)(const char* (*)())(&TGeoNodeMatrix::Class_Name),0);
   G__memfunc_setup("Class_Version",1339,G__G__Geom1_198_1_1,115,-1,G__defined_typename("Version_t"),0,0,3,1,0,"",(char*)NULL,(void*)(Version_t (*)())(&TGeoNodeMatrix::Class_Version),0);
   G__memfunc_setup("Dictionary",1046,G__G__Geom1_198_2_1,121,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)(void (*)())(&TGeoNodeMatrix::Dictionary),0);
   G__memfunc_setup("IsA",253,G__G__Geom1_198_3_1,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_198_4_1,121,-1,-1,0,2,1,1,0,
"u 'TMemberInspector' - 1 - insp C - - 0 - parent",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("Streamer",835,G__G__Geom1_198_5_1,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_198_6_1,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_198_7_1,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)(const char* (*)())(&TGeoNodeMatrix::DeclFileName),0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Geom1_198_8_1,105,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)(int (*)())(&TGeoNodeMatrix::ImplFileLine),0);
   G__memfunc_setup("ImplFileName",1171,G__G__Geom1_198_9_1,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)(const char* (*)())(&TGeoNodeMatrix::ImplFileName),0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Geom1_198_0_2,105,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)(int (*)())(&TGeoNodeMatrix::DeclFileLine),0);
   // automatic copy constructor
   G__memfunc_setup("TGeoNodeMatrix",1386,G__G__Geom1_198_1_2,(int)('i'),G__get_linked_tagnum(&G__G__Geom1LN_TGeoNodeMatrix),-1,0,1,1,1,0,"u 'TGeoNodeMatrix' - 11 - -",(char*)NULL,(void*)NULL,0);
   // automatic destructor
   G__memfunc_setup("~TGeoNodeMatrix",1512,G__G__Geom1_198_2_2,(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_198_3_2,(int)('u'),G__get_linked_tagnum(&G__G__Geom1LN_TGeoNodeMatrix),-1,1,1,1,1,0,"u 'TGeoNodeMatrix' - 11 - -",(char*)NULL,(void*)NULL,0);
   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__G__Geom1_199_1_0,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_199_2_0,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__G__Geom1_199_3_0,121,-1,-1,0,0,1,1,8,"",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("GetOffset",903,G__G__Geom1_199_4_0,100,-1,G__defined_typename("Double_t"),0,0,1,1,8,"",(char*)NULL,(void*)NULL,0);
   G__memfunc_setup("GetIndex",792,G__G__Geom1_199_5_0,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_199_6_0,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__G__Geom1_199_7_0,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__G__Geom1_199_8_0,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_199_9_0,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_199_0_1,85,G__get_linked_tagnum(&G__G__Geom1LN_TClass),-1,0,0,3,1,0,"",(char*)NULL,(void*)(TClass* (*)())(&TGeoNodeOffset::Class),0);
   G__memfunc_setup("Class_Name",982,G__G__Geom1_199_1_1,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)(const char* (*)())(&TGeoNodeOffset::Class_Name),0);
   G__memfunc_setup("Class_Version",1339,G__G__Geom1_199_2_1,115,-1,G__defined_typename("Version_t"),0,0,3,1,0,"",(char*)NULL,(void*)(Version_t (*)())(&TGeoNodeOffset::Class_Version),0);
   G__memfunc_setup("Dictionary",1046,G__G__Geom1_199_3_1,121,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)(void (*)())(&TGeoNodeOffset::Dictionary),0);
   G__memfunc_setup("IsA",253,G__G__Geom1_199_4_1,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_199_5_1,121,-1,-1,0,2,1,1,0,
"u 'TMemberInspector' - 1 - insp C - - 0 - parent",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("Streamer",835,G__G__Geom1_199_6_1,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_7_1,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_8_1,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)(const char* (*)())(&TGeoNodeOffset::DeclFileName),0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Geom1_199_9_1,105,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)(int (*)())(&TGeoNodeOffset::ImplFileLine),0);
   G__memfunc_setup("ImplFileName",1171,G__G__Geom1_199_0_2,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)(const char* (*)())(&TGeoNodeOffset::ImplFileName),0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Geom1_199_1_2,105,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)(int (*)())(&TGeoNodeOffset::DeclFileLine),0);
   // automatic copy constructor
   G__memfunc_setup("TGeoNodeOffset",1372,G__G__Geom1_199_2_2,(int)('i'),G__get_linked_tagnum(&G__G__Geom1LN_TGeoNodeOffset),-1,0,1,1,1,0,"u 'TGeoNodeOffset' - 11 - -",(char*)NULL,(void*)NULL,0);
   // automatic destructor
   G__memfunc_setup("~TGeoNodeOffset",1498,G__G__Geom1_199_3_2,(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_199_4_2,(int)('u'),G__get_linked_tagnum(&G__G__Geom1LN_TGeoNodeOffset),-1,1,1,1,1,0,"u 'TGeoNodeOffset' - 11 - -",(char*)NULL,(void*)NULL,0);
   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_200_1_0,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_200_2_0,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_200_3_0,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_200_4_0,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("ComputeBBox",1096,G__G__Geom1_200_5_0,121,-1,-1,0,0,1,1,0,"",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("ComputeNormal",1350,G__G__Geom1_200_6_0,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__G__Geom1_200_7_0,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__G__Geom1_200_8_0,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_200_9_0,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__G__Geom1_200_0_1,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__G__Geom1_200_1_1,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__G__Geom1_200_2_1,121,-1,-1,0,1,1,1,8,"D - 'Double_t' 0 - param",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("GetByteCount",1213,G__G__Geom1_200_3_1,105,-1,G__defined_typename("Int_t"),0,0,1,1,8,"",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("GetFittingBox",1310,G__G__Geom1_200_4_1,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__G__Geom1_200_5_1,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__G__Geom1_200_6_1,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_200_7_1,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_200_8_1,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_200_9_1,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_200_0_2,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_200_1_2,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_200_2_2,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_200_3_2,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_200_4_2,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_200_5_2,100,-1,G__defined_typename("Double_t"),0,0,1,1,8,"",(char*)NULL,(void*)NULL,0);
   G__memfunc_setup("InspectShape",1223,G__G__Geom1_200_6_2,121,-1,-1,0,0,1,1,8,"",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("IsCylType",902,G__G__Geom1_200_7_2,103,-1,G__defined_typename("Bool_t"),0,0,1,1,8,"",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("Safety",620,G__G__Geom1_200_8_2,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__G__Geom1_200_9_2,121,-1,-1,0,2,1,1,0,
"u 'basic_ofstream<char,char_traits<char> >' 'ofstream' 1 - out C - 'Option_t' 10 - option",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("SetDimensions",1349,G__G__Geom1_200_0_3,121,-1,-1,0,1,1,1,0,"D - 'Double_t' 0 - param",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("SetPoints",937,G__G__Geom1_200_1_3,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_200_2_3,121,-1,-1,0,1,1,1,8,"F - 'Float_t' 0 - points",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("Sizeof3D",743,G__G__Geom1_200_3_3,121,-1,-1,0,0,1,1,8,"",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("Class",502,G__G__Geom1_200_4_3,85,G__get_linked_tagnum(&G__G__Geom1LN_TClass),-1,0,0,3,1,0,"",(char*)NULL,(void*)(TClass* (*)())(&TGeoPara::Class),0);
   G__memfunc_setup("Class_Name",982,G__G__Geom1_200_5_3,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)(const char* (*)())(&TGeoPara::Class_Name),0);
   G__memfunc_setup("Class_Version",1339,G__G__Geom1_200_6_3,115,-1,G__defined_typename("Version_t"),0,0,3,1,0,"",(char*)NULL,(void*)(Version_t (*)())(&TGeoPara::Class_Version),0);
   G__memfunc_setup("Dictionary",1046,G__G__Geom1_200_7_3,121,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)(void (*)())(&TGeoPara::Dictionary),0);
   G__memfunc_setup("IsA",253,G__G__Geom1_200_8_3,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_200_9_3,121,-1,-1,0,2,1,1,0,
"u 'TMemberInspector' - 1 - insp C - - 0 - parent",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("Streamer",835,G__G__Geom1_200_0_4,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_1_4,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_2_4,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)(const char* (*)())(&TGeoPara::DeclFileName),0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Geom1_200_3_4,105,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)(int (*)())(&TGeoPara::ImplFileLine),0);
   G__memfunc_setup("ImplFileName",1171,G__G__Geom1_200_4_4,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)(const char* (*)())(&TGeoPara::ImplFileName),0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Geom1_200_5_4,105,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)(int (*)())(&TGeoPara::DeclFileLine),0);
   // automatic copy constructor
   G__memfunc_setup("TGeoPara",755,G__G__Geom1_200_6_4,(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_200_7_4,(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_200_8_4,(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_201_1_0,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_201_2_0,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_201_3_0,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_201_4_0,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("ComputeBBox",1096,G__G__Geom1_201_5_0,121,-1,-1,0,0,1,1,0,"",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("ComputeNormal",1350,G__G__Geom1_201_6_0,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_201_7_0,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*)(void (*)(Double_t*,Double_t*,Double_t*,Double_t,Double_t,Double_t))(&TGeoTube::ComputeNormalS),0);
   G__memfunc_setup("Contains",831,G__G__Geom1_201_8_0,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_201_9_0,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*)(Double_t (*)(Double_t*,Double_t*,Double_t,Double_t,Double_t))(&TGeoTube::DistFromInsideS),0);
   G__memfunc_setup("DistFromInside",1412,G__G__Geom1_201_0_1,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_201_1_1,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*)(Double_t (*)(Double_t*,Double_t*,Double_t,Double_t,Double_t))(&TGeoTube::DistFromOutsideS),0);
   G__memfunc_setup("DistFromOutside",1541,G__G__Geom1_201_2_1,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_201_3_1,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*)(void (*)(Double_t,Double_t,Double_t,Double_t,Double_t&,Double_t&))(&TGeoTube::DistToTube),0);
   G__memfunc_setup("DistancetoPrimitive",1991,G__G__Geom1_201_4_1,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__G__Geom1_201_5_1,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__G__Geom1_201_6_1,67,-1,-1,0,1,1,1,9,"i - 'Int_t' 0 - iaxis",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("GetAxisRange",1186,G__G__Geom1_201_7_1,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__G__Geom1_201_8_1,121,-1,-1,0,1,1,1,8,"D - 'Double_t' 0 - param",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("GetBuffer3D",1009,G__G__Geom1_201_9_1,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_201_0_2,105,-1,G__defined_typename("Int_t"),0,0,1,1,8,"",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("GetMakeRuntimeShape",1907,G__G__Geom1_201_1_2,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__G__Geom1_201_2_2,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_201_3_2,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_201_4_2,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_201_5_2,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_201_6_2,103,-1,G__defined_typename("Bool_t"),0,0,1,1,8,"",(char*)NULL,(void*)NULL,0);
   G__memfunc_setup("InspectShape",1223,G__G__Geom1_201_7_2,121,-1,-1,0,0,1,1,8,"",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("IsCylType",902,G__G__Geom1_201_8_2,103,-1,G__defined_typename("Bool_t"),0,0,1,1,8,"",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("MakeBuffer3D",1103,G__G__Geom1_201_9_2,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__G__Geom1_201_0_3,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_201_1_3,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*)(Double_t (*)(Double_t*,Bool_t,Double_t,Double_t,Double_t,Int_t))(&TGeoTube::SafetyS),0);
   G__memfunc_setup("SavePrimitive",1352,G__G__Geom1_201_2_3,121,-1,-1,0,2,1,1,0,
"u 'basic_ofstream<char,char_traits<char> >' 'ofstream' 1 - out C - 'Option_t' 10 - option",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("SetTubeDimensions",1749,G__G__Geom1_201_3_3,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__G__Geom1_201_4_3,121,-1,-1,0,1,1,1,0,"D - 'Double_t' 0 - param",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("SetPoints",937,G__G__Geom1_201_5_3,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_201_6_3,121,-1,-1,0,1,1,1,8,"F - 'Float_t' 0 - points",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("SetSegsAndPols",1391,G__G__Geom1_201_7_3,121,-1,-1,0,1,1,1,8,"u 'TBuffer3D' - 1 - buff",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("Sizeof3D",743,G__G__Geom1_201_8_3,121,-1,-1,0,0,1,1,8,"",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("Class",502,G__G__Geom1_201_9_3,85,G__get_linked_tagnum(&G__G__Geom1LN_TClass),-1,0,0,3,1,0,"",(char*)NULL,(void*)(TClass* (*)())(&TGeoTube::Class),0);
   G__memfunc_setup("Class_Name",982,G__G__Geom1_201_0_4,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)(const char* (*)())(&TGeoTube::Class_Name),0);
   G__memfunc_setup("Class_Version",1339,G__G__Geom1_201_1_4,115,-1,G__defined_typename("Version_t"),0,0,3,1,0,"",(char*)NULL,(void*)(Version_t (*)())(&TGeoTube::Class_Version),0);
   G__memfunc_setup("Dictionary",1046,G__G__Geom1_201_2_4,121,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)(void (*)())(&TGeoTube::Dictionary),0);
   G__memfunc_setup("IsA",253,G__G__Geom1_201_3_4,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_4_4,121,-1,-1,0,2,1,1,0,
"u 'TMemberInspector' - 1 - insp C - - 0 - parent",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("Streamer",835,G__G__Geom1_201_5_4,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_6_4,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_7_4,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)(const char* (*)())(&TGeoTube::DeclFileName),0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Geom1_201_8_4,105,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)(int (*)())(&TGeoTube::ImplFileLine),0);
   G__memfunc_setup("ImplFileName",1171,G__G__Geom1_201_9_4,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)(const char* (*)())(&TGeoTube::ImplFileName),0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Geom1_201_0_5,105,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)(int (*)())(&TGeoTube::DeclFileLine),0);
   // automatic copy constructor
   G__memfunc_setup("TGeoTube",767,G__G__Geom1_201_1_5,(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_201_2_5,(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_201_3_5,(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_202_1_0,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_202_2_0,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_202_3_0,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_202_4_0,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("ComputeBBox",1096,G__G__Geom1_202_5_0,121,-1,-1,0,0,1,1,0,"",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("ComputeNormal",1350,G__G__Geom1_202_6_0,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_202_7_0,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*)(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__G__Geom1_202_8_0,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__G__Geom1_202_9_0,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_202_0_1,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*)(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__G__Geom1_202_1_1,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_202_2_1,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*)(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__G__Geom1_202_3_1,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__G__Geom1_202_4_1,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__G__Geom1_202_5_1,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__G__Geom1_202_6_1,121,-1,-1,0,1,1,1,8,"D - 'Double_t' 0 - param",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("GetBuffer3D",1009,G__G__Geom1_202_7_1,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_202_8_1,105,-1,G__defined_typename("Int_t"),0,0,1,1,8,"",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("GetMakeRuntimeShape",1907,G__G__Geom1_202_9_1,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__G__Geom1_202_0_2,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_202_1_2,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_202_2_2,100,-1,G__defined_typename("Double_t"),0,0,1,1,8,"",(char*)NULL,(void*)NULL,0);
   G__memfunc_setup("InspectShape",1223,G__G__Geom1_202_3_2,121,-1,-1,0,0,1,1,8,"",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("MakeBuffer3D",1103,G__G__Geom1_202_4_2,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__G__Geom1_202_5_2,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_202_6_2,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*)(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__G__Geom1_202_7_2,121,-1,-1,0,2,1,1,0,
"u 'basic_ofstream<char,char_traits<char> >' 'ofstream' 1 - out C - 'Option_t' 10 - option",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("SetTubsDimensions",1763,G__G__Geom1_202_8_2,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__G__Geom1_202_9_2,121,-1,-1,0,1,1,1,0,"D - 'Double_t' 0 - param",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("SetPoints",937,G__G__Geom1_202_0_3,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_202_1_3,121,-1,-1,0,1,1,1,8,"F - 'Float_t' 0 - points",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("SetSegsAndPols",1391,G__G__Geom1_202_2_3,121,-1,-1,0,1,1,1,8,"u 'TBuffer3D' - 1 - buff",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("Sizeof3D",743,G__G__Geom1_202_3_3,121,-1,-1,0,0,1,1,8,"",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("Class",502,G__G__Geom1_202_4_3,85,G__get_linked_tagnum(&G__G__Geom1LN_TClass),-1,0,0,3,1,0,"",(char*)NULL,(void*)(TClass* (*)())(&TGeoTubeSeg::Class),0);
   G__memfunc_setup("Class_Name",982,G__G__Geom1_202_5_3,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)(const char* (*)())(&TGeoTubeSeg::Class_Name),0);
   G__memfunc_setup("Class_Version",1339,G__G__Geom1_202_6_3,115,-1,G__defined_typename("Version_t"),0,0,3,1,0,"",(char*)NULL,(void*)(Version_t (*)())(&TGeoTubeSeg::Class_Version),0);
   G__memfunc_setup("Dictionary",1046,G__G__Geom1_202_7_3,121,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)(void (*)())(&TGeoTubeSeg::Dictionary),0);
   G__memfunc_setup("IsA",253,G__G__Geom1_202_8_3,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_202_9_3,121,-1,-1,0,2,1,1,0,
"u 'TMemberInspector' - 1 - insp C - - 0 - parent",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("Streamer",835,G__G__Geom1_202_0_4,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_1_4,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_2_4,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)(const char* (*)())(&TGeoTubeSeg::DeclFileName),0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Geom1_202_3_4,105,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)(int (*)())(&TGeoTubeSeg::ImplFileLine),0);
   G__memfunc_setup("ImplFileName",1171,G__G__Geom1_202_4_4,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)(const char* (*)())(&TGeoTubeSeg::ImplFileName),0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Geom1_202_5_4,105,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)(int (*)())(&TGeoTubeSeg::DeclFileLine),0);
   // automatic copy constructor
   G__memfunc_setup("TGeoTubeSeg",1054,G__G__Geom1_202_6_4,(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_202_7_4,(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_202_8_4,(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_203_1_0,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_203_2_0,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_203_3_0,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_203_4_0,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("ComputeBBox",1096,G__G__Geom1_203_5_0,121,-1,-1,0,0,1,1,0,"",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("ComputeNormal",1350,G__G__Geom1_203_6_0,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__G__Geom1_203_7_0,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__G__Geom1_203_8_0,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_203_9_0,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__G__Geom1_203_0_1,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__G__Geom1_203_1_1,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__G__Geom1_203_2_1,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_203_3_1,105,-1,G__defined_typename("Int_t"),0,0,1,1,8,"",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("GetMakeRuntimeShape",1907,G__G__Geom1_203_4_1,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__G__Geom1_203_5_1,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_203_6_1,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_203_7_1,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_203_8_1,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__G__Geom1_203_9_1,121,-1,-1,0,0,1,1,8,"",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("Safety",620,G__G__Geom1_203_0_2,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__G__Geom1_203_1_2,121,-1,-1,0,2,1,1,0,
"u 'basic_ofstream<char,char_traits<char> >' 'ofstream' 1 - out C - 'Option_t' 10 - option",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("SetCtubDimensions",1747,G__G__Geom1_203_2_2,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__G__Geom1_203_3_2,121,-1,-1,0,1,1,1,0,"D - 'Double_t' 0 - param",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("SetPoints",937,G__G__Geom1_203_4_2,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_203_5_2,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_203_6_2,85,G__get_linked_tagnum(&G__G__Geom1LN_TClass),-1,0,0,3,1,0,"",(char*)NULL,(void*)(TClass* (*)())(&TGeoCtub::Class),0);
   G__memfunc_setup("Class_Name",982,G__G__Geom1_203_7_2,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)(const char* (*)())(&TGeoCtub::Class_Name),0);
   G__memfunc_setup("Class_Version",1339,G__G__Geom1_203_8_2,115,-1,G__defined_typename("Version_t"),0,0,3,1,0,"",(char*)NULL,(void*)(Version_t (*)())(&TGeoCtub::Class_Version),0);
   G__memfunc_setup("Dictionary",1046,G__G__Geom1_203_9_2,121,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)(void (*)())(&TGeoCtub::Dictionary),0);
   G__memfunc_setup("IsA",253,G__G__Geom1_203_0_3,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_203_1_3,121,-1,-1,0,2,1,1,0,
"u 'TMemberInspector' - 1 - insp C - - 0 - parent",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("Streamer",835,G__G__Geom1_203_2_3,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_203_3_3,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_203_4_3,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)(const char* (*)())(&TGeoCtub::DeclFileName),0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Geom1_203_5_3,105,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)(int (*)())(&TGeoCtub::ImplFileLine),0);
   G__memfunc_setup("ImplFileName",1171,G__G__Geom1_203_6_3,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)(const char* (*)())(&TGeoCtub::ImplFileName),0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Geom1_203_7_3,105,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)(int (*)())(&TGeoCtub::DeclFileLine),0);
   // automatic copy constructor
   G__memfunc_setup("TGeoCtub",765,G__G__Geom1_203_8_3,(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_203_9_3,(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_203_0_4,(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("Daxis",505,G__G__Geom1_204_1_0,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_204_2_0,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_204_3_0,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_204_4_0,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_204_5_0,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_204_6_0,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_204_7_0,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_204_8_0,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_204_9_0,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_204_0_1,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__G__Geom1_204_1_1,121,-1,-1,0,0,1,1,0,"",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("ComputeNormal",1350,G__G__Geom1_204_2_1,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__G__Geom1_204_3_1,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__G__Geom1_204_4_1,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_204_5_1,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__G__Geom1_204_6_1,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__G__Geom1_204_7_1,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__G__Geom1_204_8_1,67,-1,-1,0,1,1,1,9,"i - 'Int_t' 0 - iaxis",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("GetAxisRange",1186,G__G__Geom1_204_9_1,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__G__Geom1_204_0_2,121,-1,-1,0,1,1,1,8,"D - 'Double_t' 0 - param",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("GetBuffer3D",1009,G__G__Geom1_204_1_2,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_204_2_2,105,-1,G__defined_typename("Int_t"),0,0,1,1,8,"",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("GetMakeRuntimeShape",1907,G__G__Geom1_204_3_2,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__G__Geom1_204_4_2,105,-1,G__defined_typename("Int_t"),0,0,1,1,8,"",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("GetR",370,G__G__Geom1_204_5_2,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_204_6_2,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_204_7_2,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_204_8_2,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_204_9_2,100,-1,G__defined_typename("Double_t"),0,0,1,1,8,"",(char*)NULL,(void*)NULL,0);
   G__memfunc_setup("InspectShape",1223,G__G__Geom1_204_0_3,121,-1,-1,0,0,1,1,8,"",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("IsCylType",902,G__G__Geom1_204_1_3,103,-1,G__defined_typename("Bool_t"),0,0,1,1,8,"",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("MakeBuffer3D",1103,G__G__Geom1_204_2_3,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__G__Geom1_204_3_3,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__G__Geom1_204_4_3,121,-1,-1,0,2,1,1,0,
"u 'basic_ofstream<char,char_traits<char> >' 'ofstream' 1 - out C - 'Option_t' 10 - option",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("SetTorusDimensions",1890,G__G__Geom1_204_5_3,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__G__Geom1_204_6_3,121,-1,-1,0,1,1,1,0,"D - 'Double_t' 0 - param",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("SetPoints",937,G__G__Geom1_204_7_3,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_204_8_3,121,-1,-1,0,1,1,1,8,"F - 'Float_t' 0 - points",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("SetSegsAndPols",1391,G__G__Geom1_204_9_3,121,-1,-1,0,1,1,1,8,"u 'TBuffer3D' - 1 - buff",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("Sizeof3D",743,G__G__Geom1_204_0_4,121,-1,-1,0,0,1,1,8,"",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("Class",502,G__G__Geom1_204_1_4,85,G__get_linked_tagnum(&G__G__Geom1LN_TClass),-1,0,0,3,1,0,"",(char*)NULL,(void*)(TClass* (*)())(&TGeoTorus::Class),0);
   G__memfunc_setup("Class_Name",982,G__G__Geom1_204_2_4,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)(const char* (*)())(&TGeoTorus::Class_Name),0);
   G__memfunc_setup("Class_Version",1339,G__G__Geom1_204_3_4,115,-1,G__defined_typename("Version_t"),0,0,3,1,0,"",(char*)NULL,(void*)(Version_t (*)())(&TGeoTorus::Class_Version),0);
   G__memfunc_setup("Dictionary",1046,G__G__Geom1_204_4_4,121,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)(void (*)())(&TGeoTorus::Dictionary),0);
   G__memfunc_setup("IsA",253,G__G__Geom1_204_5_4,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_204_6_4,121,-1,-1,0,2,1,1,0,
"u 'TMemberInspector' - 1 - insp C - - 0 - parent",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("Streamer",835,G__G__Geom1_204_7_4,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_8_4,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_9_4,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)(const char* (*)())(&TGeoTorus::DeclFileName),0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Geom1_204_0_5,105,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)(int (*)())(&TGeoTorus::ImplFileLine),0);
   G__memfunc_setup("ImplFileName",1171,G__G__Geom1_204_1_5,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)(const char* (*)())(&TGeoTorus::ImplFileName),0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Geom1_204_2_5,105,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)(int (*)())(&TGeoTorus::DeclFileLine),0);
   // automatic copy constructor
   G__memfunc_setup("TGeoTorus",908,G__G__Geom1_204_3_5,(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_204_4_5,(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_5_5,(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_205_1_0,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_205_2_0,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_205_3_0,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_205_4_0,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("ComputeBBox",1096,G__G__Geom1_205_5_0,121,-1,-1,0,0,1,1,0,"",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("ComputeNormal",1350,G__G__Geom1_205_6_0,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__G__Geom1_205_7_0,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__G__Geom1_205_8_0,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__G__Geom1_205_9_0,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_205_0_1,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_205_1_1,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__G__Geom1_205_2_1,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__G__Geom1_205_3_1,67,-1,-1,0,1,1,1,9,"i - 'Int_t' 0 - iaxis",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("GetAxisRange",1186,G__G__Geom1_205_4_1,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__G__Geom1_205_5_1,121,-1,-1,0,1,1,1,8,"D - 'Double_t' 0 - param",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("GetBuffer3D",1009,G__G__Geom1_205_6_1,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_205_7_1,105,-1,G__defined_typename("Int_t"),0,0,1,1,8,"",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("GetMakeRuntimeShape",1907,G__G__Geom1_205_8_1,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__G__Geom1_205_9_1,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_205_0_2,105,-1,G__defined_typename("Int_t"),0,0,1,1,8,"",(char*)NULL,(void*)NULL,0);
   G__memfunc_setup("GetNz",488,G__G__Geom1_205_1_2,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_205_2_2,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_3_2,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_205_4_2,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_205_5_2,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_205_6_2,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_205_7_2,100,-1,G__defined_typename("Double_t"),0,0,1,1,8,"",(char*)NULL,(void*)NULL,0);
   G__memfunc_setup("InspectShape",1223,G__G__Geom1_205_8_2,121,-1,-1,0,0,1,1,8,"",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("IsCylType",902,G__G__Geom1_205_9_2,103,-1,G__defined_typename("Bool_t"),0,0,1,1,8,"",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("IsPointInside",1314,G__G__Geom1_205_0_3,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__G__Geom1_205_1_3,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__G__Geom1_205_2_3,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__G__Geom1_205_3_3,121,-1,-1,0,2,1,1,0,
"u 'basic_ofstream<char,char_traits<char> >' 'ofstream' 1 - out C - 'Option_t' 10 - option",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("SetSphDimensions",1648,G__G__Geom1_205_4_3,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_205_5_3,121,-1,-1,0,1,1,1,0,"i - 'Int_t' 0 - p",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("SetDimensions",1349,G__G__Geom1_205_6_3,121,-1,-1,0,1,1,1,0,"D - 'Double_t' 0 - param",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("SetPoints",937,G__G__Geom1_205_7_3,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_205_8_3,121,-1,-1,0,1,1,1,8,"F - 'Float_t' 0 - points",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("SetSegsAndPols",1391,G__G__Geom1_205_9_3,121,-1,-1,0,1,1,1,8,"u 'TBuffer3D' - 1 - buff",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("Sizeof3D",743,G__G__Geom1_205_0_4,121,-1,-1,0,0,1,1,8,"",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("Class",502,G__G__Geom1_205_1_4,85,G__get_linked_tagnum(&G__G__Geom1LN_TClass),-1,0,0,3,1,0,"",(char*)NULL,(void*)(TClass* (*)())(&TGeoSphere::Class),0);
   G__memfunc_setup("Class_Name",982,G__G__Geom1_205_2_4,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)(const char* (*)())(&TGeoSphere::Class_Name),0);
   G__memfunc_setup("Class_Version",1339,G__G__Geom1_205_3_4,115,-1,G__defined_typename("Version_t"),0,0,3,1,0,"",(char*)NULL,(void*)(Version_t (*)())(&TGeoSphere::Class_Version),0);
   G__memfunc_setup("Dictionary",1046,G__G__Geom1_205_4_4,121,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)(void (*)())(&TGeoSphere::Dictionary),0);
   G__memfunc_setup("IsA",253,G__G__Geom1_205_5_4,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_205_6_4,121,-1,-1,0,2,1,1,0,
"u 'TMemberInspector' - 1 - insp C - - 0 - parent",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("Streamer",835,G__G__Geom1_205_7_4,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_8_4,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_9_4,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)(const char* (*)())(&TGeoSphere::DeclFileName),0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Geom1_205_0_5,105,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)(int (*)())(&TGeoSphere::ImplFileLine),0);
   G__memfunc_setup("ImplFileName",1171,G__G__Geom1_205_1_5,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)(const char* (*)())(&TGeoSphere::ImplFileName),0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Geom1_205_2_5,105,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)(int (*)())(&TGeoSphere::DeclFileLine),0);
   // automatic copy constructor
   G__memfunc_setup("TGeoSphere",982,G__G__Geom1_205_3_5,(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_205_4_5,(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_5_5,(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_206_1_0,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_206_2_0,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_206_3_0,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_206_4_0,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("ComputeBBox",1096,G__G__Geom1_206_5_0,121,-1,-1,0,0,1,1,0,"",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("ComputeNormal",1350,G__G__Geom1_206_6_0,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__G__Geom1_206_7_0,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__G__Geom1_206_8_0,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__G__Geom1_206_9_0,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_206_0_1,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__G__Geom1_206_1_1,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_206_2_1,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_206_3_1,100,-1,G__defined_typename("Double_t"),0,0,1,1,8,"",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("GetBoundingCylinder",1936,G__G__Geom1_206_4_1,121,-1,-1,0,1,1,1,8,"D - 'Double_t' 0 - param",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("GetBuffer3D",1009,G__G__Geom1_206_5_1,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__G__Geom1_206_6_1,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__G__Geom1_206_7_1,105,-1,G__defined_typename("Int_t"),0,0,1,1,8,"",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("InspectShape",1223,G__G__Geom1_206_8_1,121,-1,-1,0,0,1,1,8,"",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("IsCylType",902,G__G__Geom1_206_9_1,103,-1,G__defined_typename("Bool_t"),0,0,1,1,8,"",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("Safety",620,G__G__Geom1_206_0_2,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__G__Geom1_206_1_2,121,-1,-1,0,2,1,1,0,
"u 'basic_ofstream<char,char_traits<char> >' 'ofstream' 1 - out C - 'Option_t' 10 - option",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("SetEltuDimensions",1759,G__G__Geom1_206_2_2,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__G__Geom1_206_3_2,121,-1,-1,0,1,1,1,0,"D - 'Double_t' 0 - param",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("SetPoints",937,G__G__Geom1_206_4_2,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_206_5_2,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_206_6_2,85,G__get_linked_tagnum(&G__G__Geom1LN_TClass),-1,0,0,3,1,0,"",(char*)NULL,(void*)(TClass* (*)())(&TGeoEltu::Class),0);
   G__memfunc_setup("Class_Name",982,G__G__Geom1_206_7_2,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)(const char* (*)())(&TGeoEltu::Class_Name),0);
   G__memfunc_setup("Class_Version",1339,G__G__Geom1_206_8_2,115,-1,G__defined_typename("Version_t"),0,0,3,1,0,"",(char*)NULL,(void*)(Version_t (*)())(&TGeoEltu::Class_Version),0);
   G__memfunc_setup("Dictionary",1046,G__G__Geom1_206_9_2,121,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)(void (*)())(&TGeoEltu::Dictionary),0);
   G__memfunc_setup("IsA",253,G__G__Geom1_206_0_3,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_206_1_3,121,-1,-1,0,2,1,1,0,
"u 'TMemberInspector' - 1 - insp C - - 0 - parent",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("Streamer",835,G__G__Geom1_206_2_3,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_3_3,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_4_3,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)(const char* (*)())(&TGeoEltu::DeclFileName),0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Geom1_206_5_3,105,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)(int (*)())(&TGeoEltu::ImplFileLine),0);
   G__memfunc_setup("ImplFileName",1171,G__G__Geom1_206_6_3,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)(const char* (*)())(&TGeoEltu::ImplFileName),0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Geom1_206_7_3,105,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)(int (*)())(&TGeoEltu::DeclFileLine),0);
   // automatic copy constructor
   G__memfunc_setup("TGeoEltu",777,G__G__Geom1_206_8_3,(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_206_9_3,(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_4,(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_207_1_0,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_207_2_0,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_207_3_0,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_207_4_0,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("ComputeBBox",1096,G__G__Geom1_207_5_0,121,-1,-1,0,0,1,1,0,"",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("ComputeNormal",1350,G__G__Geom1_207_6_0,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__G__Geom1_207_7_0,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__G__Geom1_207_8_0,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_207_9_0,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_207_0_1,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__G__Geom1_207_1_1,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__G__Geom1_207_2_1,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__G__Geom1_207_3_1,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__G__Geom1_207_4_1,121,-1,-1,0,1,1,1,8,"D - 'Double_t' 0 - param",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("GetBuffer3D",1009,G__G__Geom1_207_5_1,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_207_6_1,105,-1,G__defined_typename("Int_t"),0,0,1,1,8,"",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("GetMakeRuntimeShape",1907,G__G__Geom1_207_7_1,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__G__Geom1_207_8_1,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_207_9_1,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_207_0_2,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_207_1_2,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_207_2_2,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_207_3_2,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__G__Geom1_207_4_2,121,-1,-1,0,0,1,1,8,"",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("IsCylType",902,G__G__Geom1_207_5_2,103,-1,G__defined_typename("Bool_t"),0,0,1,1,8,"",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("MakeBuffer3D",1103,G__G__Geom1_207_6_2,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__G__Geom1_207_7_2,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_207_8_2,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__G__Geom1_207_9_2,121,-1,-1,0,2,1,1,0,
"u 'basic_ofstream<char,char_traits<char> >' 'ofstream' 1 - out C - 'Option_t' 10 - option",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("SetHypeDimensions",1755,G__G__Geom1_207_0_3,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__G__Geom1_207_1_3,121,-1,-1,0,1,1,1,0,"D - 'Double_t' 0 - param",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("SetPoints",937,G__G__Geom1_207_2_3,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_207_3_3,121,-1,-1,0,1,1,1,8,"F - 'Float_t' 0 - points",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("SetSegsAndPols",1391,G__G__Geom1_207_4_3,121,-1,-1,0,1,1,1,8,"u 'TBuffer3D' - 1 - buff",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("Sizeof3D",743,G__G__Geom1_207_5_3,121,-1,-1,0,0,1,1,8,"",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("Class",502,G__G__Geom1_207_6_3,85,G__get_linked_tagnum(&G__G__Geom1LN_TClass),-1,0,0,3,1,0,"",(char*)NULL,(void*)(TClass* (*)())(&TGeoHype::Class),0);
   G__memfunc_setup("Class_Name",982,G__G__Geom1_207_7_3,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)(const char* (*)())(&TGeoHype::Class_Name),0);
   G__memfunc_setup("Class_Version",1339,G__G__Geom1_207_8_3,115,-1,G__defined_typename("Version_t"),0,0,3,1,0,"",(char*)NULL,(void*)(Version_t (*)())(&TGeoHype::Class_Version),0);
   G__memfunc_setup("Dictionary",1046,G__G__Geom1_207_9_3,121,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)(void (*)())(&TGeoHype::Dictionary),0);
   G__memfunc_setup("IsA",253,G__G__Geom1_207_0_4,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_207_1_4,121,-1,-1,0,2,1,1,0,
"u 'TMemberInspector' - 1 - insp C - - 0 - parent",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("Streamer",835,G__G__Geom1_207_2_4,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_3_4,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_4_4,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)(const char* (*)())(&TGeoHype::DeclFileName),0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Geom1_207_5_4,105,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)(int (*)())(&TGeoHype::ImplFileLine),0);
   G__memfunc_setup("ImplFileName",1171,G__G__Geom1_207_6_4,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)(const char* (*)())(&TGeoHype::ImplFileName),0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Geom1_207_7_4,105,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)(int (*)())(&TGeoHype::DeclFileLine),0);
   // automatic copy constructor
   G__memfunc_setup("TGeoHype",773,G__G__Geom1_207_8_4,(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_207_9_4,(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_5,(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_208_1_0,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_208_2_0,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_208_3_0,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_208_4_0,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("ComputeBBox",1096,G__G__Geom1_208_5_0,121,-1,-1,0,0,1,1,0,"",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("ComputeNormal",1350,G__G__Geom1_208_6_0,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_208_7_0,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*)(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__G__Geom1_208_8_0,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__G__Geom1_208_9_0,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_208_0_1,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*)(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_208_1_1,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*)(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__G__Geom1_208_2_1,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_208_3_1,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*)(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__G__Geom1_208_4_1,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__G__Geom1_208_5_1,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__G__Geom1_208_6_1,67,-1,-1,0,1,1,1,9,"i - 'Int_t' 0 - iaxis",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("GetAxisRange",1186,G__G__Geom1_208_7_1,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__G__Geom1_208_8_1,121,-1,-1,0,1,1,1,8,"D - 'Double_t' 0 - param",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("GetByteCount",1213,G__G__Geom1_208_9_1,105,-1,G__defined_typename("Int_t"),0,0,1,1,8,"",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("GetBuffer3D",1009,G__G__Geom1_208_0_2,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_208_1_2,100,-1,G__defined_typename("Double_t"),0,0,1,1,8,"",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("GetMakeRuntimeShape",1907,G__G__Geom1_208_2_2,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__G__Geom1_208_3_2,105,-1,G__defined_typename("Int_t"),0,0,1,1,8,"",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("GetRmin1",743,G__G__Geom1_208_4_2,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_208_5_2,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_208_6_2,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_208_7_2,100,-1,G__defined_typename("Double_t"),0,0,1,1,8,"",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("InspectShape",1223,G__G__Geom1_208_8_2,121,-1,-1,0,0,1,1,8,"",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("IsCylType",902,G__G__Geom1_208_9_2,103,-1,G__defined_typename("Bool_t"),0,0,1,1,8,"",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("MakeBuffer3D",1103,G__G__Geom1_208_0_3,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__G__Geom1_208_1_3,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_208_2_3,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*)(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__G__Geom1_208_3_3,121,-1,-1,0,2,1,1,0,
"u 'basic_ofstream<char,char_traits<char> >' 'ofstream' 1 - out C - 'Option_t' 10 - option",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("SetConeDimensions",1738,G__G__Geom1_208_4_3,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__G__Geom1_208_5_3,121,-1,-1,0,1,1,1,0,"D - 'Double_t' 0 - param",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("SetPoints",937,G__G__Geom1_208_6_3,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_208_7_3,121,-1,-1,0,1,1,1,8,"F - 'Float_t' 0 - points",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("SetSegsAndPols",1391,G__G__Geom1_208_8_3,121,-1,-1,0,1,1,1,8,"u 'TBuffer3D' - 1 - buffer",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("Sizeof3D",743,G__G__Geom1_208_9_3,121,-1,-1,0,0,1,1,8,"",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("Class",502,G__G__Geom1_208_0_4,85,G__get_linked_tagnum(&G__G__Geom1LN_TClass),-1,0,0,3,1,0,"",(char*)NULL,(void*)(TClass* (*)())(&TGeoCone::Class),0);
   G__memfunc_setup("Class_Name",982,G__G__Geom1_208_1_4,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)(const char* (*)())(&TGeoCone::Class_Name),0);
   G__memfunc_setup("Class_Version",1339,G__G__Geom1_208_2_4,115,-1,G__defined_typename("Version_t"),0,0,3,1,0,"",(char*)NULL,(void*)(Version_t (*)())(&TGeoCone::Class_Version),0);
   G__memfunc_setup("Dictionary",1046,G__G__Geom1_208_3_4,121,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)(void (*)())(&TGeoCone::Dictionary),0);
   G__memfunc_setup("IsA",253,G__G__Geom1_208_4_4,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_208_5_4,121,-1,-1,0,2,1,1,0,
"u 'TMemberInspector' - 1 - insp C - - 0 - parent",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("Streamer",835,G__G__Geom1_208_6_4,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_7_4,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_8_4,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)(const char* (*)())(&TGeoCone::DeclFileName),0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Geom1_208_9_4,105,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)(int (*)())(&TGeoCone::ImplFileLine),0);
   G__memfunc_setup("ImplFileName",1171,G__G__Geom1_208_0_5,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)(const char* (*)())(&TGeoCone::ImplFileName),0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Geom1_208_1_5,105,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)(int (*)())(&TGeoCone::DeclFileLine),0);
   // automatic copy constructor
   G__memfunc_setup("TGeoCone",756,G__G__Geom1_208_2_5,(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_208_3_5,(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_4_5,(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_209_1_0,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_209_2_0,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_209_3_0,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_209_4_0,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("ComputeBBox",1096,G__G__Geom1_209_5_0,121,-1,-1,0,0,1,1,0,"",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("ComputeNormal",1350,G__G__Geom1_209_6_0,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_209_7_0,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*)(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__G__Geom1_209_8_0,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__G__Geom1_209_9_0,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_209_0_1,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*)(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_209_1_1,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*)(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__G__Geom1_209_2_1,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_209_3_1,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*)(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__G__Geom1_209_4_1,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__G__Geom1_209_5_1,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__G__Geom1_209_6_1,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__G__Geom1_209_7_1,121,-1,-1,0,1,1,1,8,"D - 'Double_t' 0 - param",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("GetBuffer3D",1009,G__G__Geom1_209_8_1,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_209_9_1,105,-1,G__defined_typename("Int_t"),0,0,1,1,8,"",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("GetMakeRuntimeShape",1907,G__G__Geom1_209_0_2,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__G__Geom1_209_1_2,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_209_2_2,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_3_2,100,-1,G__defined_typename("Double_t"),0,0,1,1,8,"",(char*)NULL,(void*)NULL,0);
   G__memfunc_setup("InspectShape",1223,G__G__Geom1_209_4_2,121,-1,-1,0,0,1,1,8,"",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("MakeBuffer3D",1103,G__G__Geom1_209_5_2,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__G__Geom1_209_6_2,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_209_7_2,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*)(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__G__Geom1_209_8_2,121,-1,-1,0,2,1,1,0,
"u 'basic_ofstream<char,char_traits<char> >' 'ofstream' 1 - out C - 'Option_t' 10 - option",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("SetConsDimensions",1752,G__G__Geom1_209_9_2,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__G__Geom1_209_0_3,121,-1,-1,0,1,1,1,0,"D - 'Double_t' 0 - param",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("SetPoints",937,G__G__Geom1_209_1_3,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_209_2_3,121,-1,-1,0,1,1,1,8,"F - 'Float_t' 0 - points",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("SetSegsAndPols",1391,G__G__Geom1_209_3_3,121,-1,-1,0,1,1,1,8,"u 'TBuffer3D' - 1 - buffer",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("Sizeof3D",743,G__G__Geom1_209_4_3,121,-1,-1,0,0,1,1,8,"",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("Class",502,G__G__Geom1_209_5_3,85,G__get_linked_tagnum(&G__G__Geom1LN_TClass),-1,0,0,3,1,0,"",(char*)NULL,(void*)(TClass* (*)())(&TGeoConeSeg::Class),0);
   G__memfunc_setup("Class_Name",982,G__G__Geom1_209_6_3,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)(const char* (*)())(&TGeoConeSeg::Class_Name),0);
   G__memfunc_setup("Class_Version",1339,G__G__Geom1_209_7_3,115,-1,G__defined_typename("Version_t"),0,0,3,1,0,"",(char*)NULL,(void*)(Version_t (*)())(&TGeoConeSeg::Class_Version),0);
   G__memfunc_setup("Dictionary",1046,G__G__Geom1_209_8_3,121,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)(void (*)())(&TGeoConeSeg::Dictionary),0);
   G__memfunc_setup("IsA",253,G__G__Geom1_209_9_3,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_209_0_4,121,-1,-1,0,2,1,1,0,
"u 'TMemberInspector' - 1 - insp C - - 0 - parent",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("Streamer",835,G__G__Geom1_209_1_4,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_2_4,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_3_4,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)(const char* (*)())(&TGeoConeSeg::DeclFileName),0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Geom1_209_4_4,105,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)(int (*)())(&TGeoConeSeg::ImplFileLine),0);
   G__memfunc_setup("ImplFileName",1171,G__G__Geom1_209_5_4,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)(const char* (*)())(&TGeoConeSeg::ImplFileName),0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Geom1_209_6_4,105,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)(int (*)())(&TGeoConeSeg::DeclFileLine),0);
   // automatic copy constructor
   G__memfunc_setup("TGeoConeSeg",1043,G__G__Geom1_209_7_4,(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_209_8_4,(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_9_4,(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__G__Geom1_210_1_0,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_210_2_0,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_210_3_0,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_210_4_0,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("ComputeBBox",1096,G__G__Geom1_210_5_0,121,-1,-1,0,0,1,1,0,"",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("ComputeNormal",1350,G__G__Geom1_210_6_0,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__G__Geom1_210_7_0,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_210_8_0,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__G__Geom1_210_9_0,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_210_0_1,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_210_1_1,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__G__Geom1_210_2_1,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__G__Geom1_210_3_1,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__G__Geom1_210_4_1,67,-1,-1,0,1,1,1,9,"i - 'Int_t' 0 - iaxis",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("GetAxisRange",1186,G__G__Geom1_210_5_1,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__G__Geom1_210_6_1,121,-1,-1,0,1,1,1,8,"D - 'Double_t' 0 - param",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("GetBuffer3D",1009,G__G__Geom1_210_7_1,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_210_8_1,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_210_9_1,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_210_0_2,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_210_1_2,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_210_2_2,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_210_3_2,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_210_4_2,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_210_5_2,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_210_6_2,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_210_7_2,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_210_8_2,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__G__Geom1_210_9_2,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__G__Geom1_210_0_3,105,-1,G__defined_typename("Int_t"),0,0,1,1,8,"",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("InspectShape",1223,G__G__Geom1_210_1_3,121,-1,-1,0,0,1,1,8,"",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("IsCylType",902,G__G__Geom1_210_2_3,103,-1,G__defined_typename("Bool_t"),0,0,1,1,8,"",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("MakeBuffer3D",1103,G__G__Geom1_210_3_3,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_210_4_3,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_210_5_3,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_210_6_3,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_210_7_3,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_210_8_3,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__G__Geom1_210_9_3,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_210_0_4,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__G__Geom1_210_1_4,121,-1,-1,0,2,1,1,0,
"u 'basic_ofstream<char,char_traits<char> >' 'ofstream' 1 - out C - 'Option_t' 10 - option",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("SetDimensions",1349,G__G__Geom1_210_2_4,121,-1,-1,0,1,1,1,0,"D - 'Double_t' 0 - param",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("SetPoints",937,G__G__Geom1_210_3_4,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_210_4_4,121,-1,-1,0,1,1,1,8,"F - 'Float_t' 0 - points",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("SetSegsAndPols",1391,G__G__Geom1_210_5_4,121,-1,-1,0,1,1,1,8,"u 'TBuffer3D' - 1 - buff",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("Sizeof3D",743,G__G__Geom1_210_6_4,121,-1,-1,0,0,1,1,8,"",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("Class",502,G__G__Geom1_210_7_4,85,G__get_linked_tagnum(&G__G__Geom1LN_TClass),-1,0,0,3,1,0,"",(char*)NULL,(void*)(TClass* (*)())(&TGeoPcon::Class),0);
   G__memfunc_setup("Class_Name",982,G__G__Geom1_210_8_4,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)(const char* (*)())(&TGeoPcon::Class_Name),0);
   G__memfunc_setup("Class_Version",1339,G__G__Geom1_210_9_4,115,-1,G__defined_typename("Version_t"),0,0,3,1,0,"",(char*)NULL,(void*)(Version_t (*)())(&TGeoPcon::Class_Version),0);
   G__memfunc_setup("Dictionary",1046,G__G__Geom1_210_0_5,121,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)(void (*)())(&TGeoPcon::Dictionary),0);
   G__memfunc_setup("IsA",253,G__G__Geom1_210_1_5,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_210_2_5,121,-1,-1,0,2,1,1,0,
"u 'TMemberInspector' - 1 - insp C - - 0 - parent",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("Streamer",835,G__G__Geom1_210_3_5,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_4_5,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_5_5,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)(const char* (*)())(&TGeoPcon::DeclFileName),0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Geom1_210_6_5,105,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)(int (*)())(&TGeoPcon::ImplFileLine),0);
   G__memfunc_setup("ImplFileName",1171,G__G__Geom1_210_7_5,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)(const char* (*)())(&TGeoPcon::ImplFileName),0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Geom1_210_8_5,105,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)(int (*)())(&TGeoPcon::DeclFileLine),0);
   // automatic copy constructor
   G__memfunc_setup("TGeoPcon",767,G__G__Geom1_210_9_5,(int)('i'),G__get_linked_tagnum(&G__G__Geom1LN_TGeoPcon),-1,0,1,1,1,0,"u 'TGeoPcon' - 11 - -",(char*)NULL,(void*)NULL,0);
   // automatic destructor
   G__memfunc_setup("~TGeoPcon",893,G__G__Geom1_210_0_6,(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_1_6,(int)('u'),G__get_linked_tagnum(&G__G__Geom1LN_TGeoPcon),-1,1,1,1,1,0,"u 'TGeoPcon' - 11 - -",(char*)NULL,(void*)NULL,0);
   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_211_0_1,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_211_1_1,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_211_2_1,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_211_3_1,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("ComputeBBox",1096,G__G__Geom1_211_4_1,121,-1,-1,0,0,1,1,0,"",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("ComputeNormal",1350,G__G__Geom1_211_5_1,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__G__Geom1_211_6_1,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_211_7_1,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__G__Geom1_211_8_1,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_211_9_1,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__G__Geom1_211_0_2,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__G__Geom1_211_1_2,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__G__Geom1_211_2_2,121,-1,-1,0,1,1,1,8,"D - 'Double_t' 0 - param",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("GetBuffer3D",1009,G__G__Geom1_211_3_2,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_211_4_2,105,-1,G__defined_typename("Int_t"),0,0,1,1,8,"",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("GetMakeRuntimeShape",1907,G__G__Geom1_211_5_2,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("GetNedges",886,G__G__Geom1_211_6_2,105,-1,G__defined_typename("Int_t"),0,0,1,1,8,"",(char*)NULL,(void*)NULL,0);
   G__memfunc_setup("GetNmeshVertices",1632,G__G__Geom1_211_7_2,105,-1,G__defined_typename("Int_t"),0,0,1,1,8,"",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("GetNsegments",1236,G__G__Geom1_211_8_2,105,-1,G__defined_typename("Int_t"),0,0,1,1,8,"",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("InspectShape",1223,G__G__Geom1_211_9_2,121,-1,-1,0,0,1,1,8,"",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("MakeBuffer3D",1103,G__G__Geom1_211_0_3,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__G__Geom1_211_1_3,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_211_2_3,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__G__Geom1_211_3_3,121,-1,-1,0,2,1,1,0,
"u 'basic_ofstream<char,char_traits<char> >' 'ofstream' 1 - out C - 'Option_t' 10 - option",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("SetDimensions",1349,G__G__Geom1_211_4_3,121,-1,-1,0,1,1,1,0,"D - 'Double_t' 0 - param",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("SetPoints",937,G__G__Geom1_211_5_3,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_211_6_3,121,-1,-1,0,1,1,1,8,"F - 'Float_t' 0 - points",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("SetSegsAndPols",1391,G__G__Geom1_211_7_3,121,-1,-1,0,1,1,1,8,"u 'TBuffer3D' - 1 - buff",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("Sizeof3D",743,G__G__Geom1_211_8_3,121,-1,-1,0,0,1,1,8,"",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("Class",502,G__G__Geom1_211_9_3,85,G__get_linked_tagnum(&G__G__Geom1LN_TClass),-1,0,0,3,1,0,"",(char*)NULL,(void*)(TClass* (*)())(&TGeoPgon::Class),0);
   G__memfunc_setup("Class_Name",982,G__G__Geom1_211_0_4,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)(const char* (*)())(&TGeoPgon::Class_Name),0);
   G__memfunc_setup("Class_Version",1339,G__G__Geom1_211_1_4,115,-1,G__defined_typename("Version_t"),0,0,3,1,0,"",(char*)NULL,(void*)(Version_t (*)())(&TGeoPgon::Class_Version),0);
   G__memfunc_setup("Dictionary",1046,G__G__Geom1_211_2_4,121,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)(void (*)())(&TGeoPgon::Dictionary),0);
   G__memfunc_setup("IsA",253,G__G__Geom1_211_3_4,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_211_4_4,121,-1,-1,0,2,1,1,0,
"u 'TMemberInspector' - 1 - insp C - - 0 - parent",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("Streamer",835,G__G__Geom1_211_5_4,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_6_4,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_7_4,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)(const char* (*)())(&TGeoPgon::DeclFileName),0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Geom1_211_8_4,105,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)(int (*)())(&TGeoPgon::ImplFileLine),0);
   G__memfunc_setup("ImplFileName",1171,G__G__Geom1_211_9_4,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)(const char* (*)())(&TGeoPgon::ImplFileName),0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Geom1_211_0_5,105,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)(int (*)())(&TGeoPgon::DeclFileLine),0);
   // automatic copy constructor
   G__memfunc_setup("TGeoPgon",771,G__G__Geom1_211_1_5,(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_211_2_5,(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_3_5,(int)('u'),G__get_linked_tagnum(&G__G__Geom1LN_TGeoPgon),-1,1,1,1,1,0,"u 'TGeoPgon' - 11 - -",(char*)NULL,(void*)NULL,0);
   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__G__Geom1_212_1_0,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_212_2_0,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_212_3_0,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("ComputeBBox",1096,G__G__Geom1_212_4_0,121,-1,-1,0,0,1,1,0,"",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("ComputeNormal",1350,G__G__Geom1_212_5_0,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_212_6_0,121,-1,-1,0,0,1,1,0,"",(char*)NULL,(void*)NULL,0);
   G__memfunc_setup("Contains",831,G__G__Geom1_212_7_0,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_212_8_0,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__G__Geom1_212_9_0,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_212_0_1,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__G__Geom1_212_1_1,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__G__Geom1_212_2_1,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__G__Geom1_212_3_1,121,-1,-1,0,1,1,1,8,"D - 'Double_t' 0 - param",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("GetByteCount",1213,G__G__Geom1_212_4_1,105,-1,G__defined_typename("Int_t"),0,0,1,1,8,"",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("GetDz",478,G__G__Geom1_212_5_1,100,-1,G__defined_typename("Double_t"),0,0,1,1,8,"",(char*)NULL,(void*)NULL,0);
   G__memfunc_setup("GetFittingBox",1310,G__G__Geom1_212_6_1,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__G__Geom1_212_7_1,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_212_8_1,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*)(void (*)(Double_t*,Double_t*,Double_t*,Double_t*))(&TGeoArb8::GetPlaneNormal),0);
   G__memfunc_setup("GetNmeshVertices",1632,G__G__Geom1_212_9_1,105,-1,G__defined_typename("Int_t"),0,0,1,1,8,"",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("GetVertices",1125,G__G__Geom1_212_0_2,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_212_1_2,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__G__Geom1_212_2_2,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_212_3_2,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*)(Bool_t (*)(Double_t*,Double_t*))(&TGeoArb8::IsSamePoint),0);
   G__memfunc_setup("InsidePolygon",1348,G__G__Geom1_212_4_2,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*)(Bool_t (*)(Double_t,Double_t,Double_t*))(&TGeoArb8::InsidePolygon),0);
   G__memfunc_setup("InspectShape",1223,G__G__Geom1_212_5_2,121,-1,-1,0,0,1,1,8,"",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("IsTwisted",928,G__G__Geom1_212_6_2,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_212_7_2,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__G__Geom1_212_8_2,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__G__Geom1_212_9_2,121,-1,-1,0,2,1,1,0,
"u 'basic_ofstream<char,char_traits<char> >' 'ofstream' 1 - out C - 'Option_t' 10 - option",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("SetPlaneVertices",1633,G__G__Geom1_212_0_3,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_212_1_3,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__G__Geom1_212_2_3,121,-1,-1,0,1,1,1,0,"D - 'Double_t' 0 - param",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("SetPoints",937,G__G__Geom1_212_3_3,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_212_4_3,121,-1,-1,0,1,1,1,8,"F - 'Float_t' 0 - points",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("Sizeof3D",743,G__G__Geom1_212_5_3,121,-1,-1,0,0,1,1,8,"",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("Class",502,G__G__Geom1_212_6_3,85,G__get_linked_tagnum(&G__G__Geom1LN_TClass),-1,0,0,3,1,0,"",(char*)NULL,(void*)(TClass* (*)())(&TGeoArb8::Class),0);
   G__memfunc_setup("Class_Name",982,G__G__Geom1_212_7_3,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)(const char* (*)())(&TGeoArb8::Class_Name),0);
   G__memfunc_setup("Class_Version",1339,G__G__Geom1_212_8_3,115,-1,G__defined_typename("Version_t"),0,0,3,1,0,"",(char*)NULL,(void*)(Version_t (*)())(&TGeoArb8::Class_Version),0);
   G__memfunc_setup("Dictionary",1046,G__G__Geom1_212_9_3,121,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)(void (*)())(&TGeoArb8::Dictionary),0);
   G__memfunc_setup("IsA",253,G__G__Geom1_212_0_4,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_212_1_4,121,-1,-1,0,2,1,1,0,
"u 'TMemberInspector' - 1 - insp C - - 0 - parent",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("Streamer",835,G__G__Geom1_212_2_4,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_3_4,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_4_4,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)(const char* (*)())(&TGeoArb8::DeclFileName),0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Geom1_212_5_4,105,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)(int (*)())(&TGeoArb8::ImplFileLine),0);
   G__memfunc_setup("ImplFileName",1171,G__G__Geom1_212_6_4,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)(const char* (*)())(&TGeoArb8::ImplFileName),0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Geom1_212_7_4,105,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)(int (*)())(&TGeoArb8::DeclFileLine),0);
   // automatic copy constructor
   G__memfunc_setup("TGeoArb8",700,G__G__Geom1_212_8_4,(int)('i'),G__get_linked_tagnum(&G__G__Geom1LN_TGeoArb8),-1,0,1,1,1,0,"u 'TGeoArb8' - 11 - -",(char*)NULL,(void*)NULL,0);
   // automatic destructor
   G__memfunc_setup("~TGeoArb8",826,G__G__Geom1_212_9_4,(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_5,(int)('u'),G__get_linked_tagnum(&G__G__Geom1LN_TGeoArb8),-1,1,1,1,1,0,"u 'TGeoArb8' - 11 - -",(char*)NULL,(void*)NULL,0);
   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_214_1_0,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_214_2_0,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_214_3_0,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_214_4_0,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__G__Geom1_214_5_0,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_214_6_0,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__G__Geom1_214_7_0,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_214_8_0,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_214_9_0,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_214_0_1,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_214_1_1,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_214_2_1,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_214_3_1,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_214_4_1,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_214_5_1,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_214_6_1,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_214_7_1,100,-1,G__defined_typename("Double_t"),0,0,1,1,8,"",(char*)NULL,(void*)NULL,0);
   G__memfunc_setup("GetMakeRuntimeShape",1907,G__G__Geom1_214_8_1,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__G__Geom1_214_9_1,105,-1,G__defined_typename("Int_t"),0,0,1,1,8,"",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("Safety",620,G__G__Geom1_214_0_2,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__G__Geom1_214_1_2,121,-1,-1,0,2,1,1,0,
"u 'basic_ofstream<char,char_traits<char> >' 'ofstream' 1 - out C - 'Option_t' 10 - option",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("Class",502,G__G__Geom1_214_2_2,85,G__get_linked_tagnum(&G__G__Geom1LN_TClass),-1,0,0,3,1,0,"",(char*)NULL,(void*)(TClass* (*)())(&TGeoTrap::Class),0);
   G__memfunc_setup("Class_Name",982,G__G__Geom1_214_3_2,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)(const char* (*)())(&TGeoTrap::Class_Name),0);
   G__memfunc_setup("Class_Version",1339,G__G__Geom1_214_4_2,115,-1,G__defined_typename("Version_t"),0,0,3,1,0,"",(char*)NULL,(void*)(Version_t (*)())(&TGeoTrap::Class_Version),0);
   G__memfunc_setup("Dictionary",1046,G__G__Geom1_214_5_2,121,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)(void (*)())(&TGeoTrap::Dictionary),0);
   G__memfunc_setup("IsA",253,G__G__Geom1_214_6_2,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_214_7_2,121,-1,-1,0,2,1,1,0,
"u 'TMemberInspector' - 1 - insp C - - 0 - parent",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("Streamer",835,G__G__Geom1_214_8_2,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_9_2,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_3,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)(const char* (*)())(&TGeoTrap::DeclFileName),0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Geom1_214_1_3,105,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)(int (*)())(&TGeoTrap::ImplFileLine),0);
   G__memfunc_setup("ImplFileName",1171,G__G__Geom1_214_2_3,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)(const char* (*)())(&TGeoTrap::ImplFileName),0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Geom1_214_3_3,105,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)(int (*)())(&TGeoTrap::DeclFileLine),0);
   // automatic copy constructor
   G__memfunc_setup("TGeoTrap",774,G__G__Geom1_214_4_3,(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_214_5_3,(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_214_6_3,(int)('u'),G__get_linked_tagnum(&G__G__Geom1LN_TGeoTrap),-1,1,1,1,1,0,"u 'TGeoTrap' - 11 - -",(char*)NULL,(void*)NULL,0);
   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_215_1_0,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_215_2_0,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_215_3_0,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__G__Geom1_215_4_0,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_215_5_0,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__G__Geom1_215_6_0,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__G__Geom1_215_7_0,105,-1,G__defined_typename("Int_t"),0,0,1,1,8,"",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("GetTwistAngle",1314,G__G__Geom1_215_8_0,100,-1,G__defined_typename("Double_t"),0,0,1,1,8,"",(char*)NULL,(void*)NULL,0);
   G__memfunc_setup("SavePrimitive",1352,G__G__Geom1_215_9_0,121,-1,-1,0,2,1,1,0,
"u 'basic_ofstream<char,char_traits<char> >' 'ofstream' 1 - out C - 'Option_t' 10 - option",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("Class",502,G__G__Geom1_215_0_1,85,G__get_linked_tagnum(&G__G__Geom1LN_TClass),-1,0,0,3,1,0,"",(char*)NULL,(void*)(TClass* (*)())(&TGeoGtra::Class),0);
   G__memfunc_setup("Class_Name",982,G__G__Geom1_215_1_1,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)(const char* (*)())(&TGeoGtra::Class_Name),0);
   G__memfunc_setup("Class_Version",1339,G__G__Geom1_215_2_1,115,-1,G__defined_typename("Version_t"),0,0,3,1,0,"",(char*)NULL,(void*)(Version_t (*)())(&TGeoGtra::Class_Version),0);
   G__memfunc_setup("Dictionary",1046,G__G__Geom1_215_3_1,121,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)(void (*)())(&TGeoGtra::Dictionary),0);
   G__memfunc_setup("IsA",253,G__G__Geom1_215_4_1,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_215_5_1,121,-1,-1,0,2,1,1,0,
"u 'TMemberInspector' - 1 - insp C - - 0 - parent",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("Streamer",835,G__G__Geom1_215_6_1,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_7_1,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_8_1,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)(const char* (*)())(&TGeoGtra::DeclFileName),0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Geom1_215_9_1,105,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)(int (*)())(&TGeoGtra::ImplFileLine),0);
   G__memfunc_setup("ImplFileName",1171,G__G__Geom1_215_0_2,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)(const char* (*)())(&TGeoGtra::ImplFileName),0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Geom1_215_1_2,105,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)(int (*)())(&TGeoGtra::DeclFileLine),0);
   // automatic copy constructor
   G__memfunc_setup("TGeoGtra",765,G__G__Geom1_215_2_2,(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_215_3_2,(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_215_4_2,(int)('u'),G__get_linked_tagnum(&G__G__Geom1LN_TGeoGtra),-1,1,1,1,1,0,"u 'TGeoGtra' - 11 - -",(char*)NULL,(void*)NULL,0);
   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_216_1_0,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_216_2_0,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_216_3_0,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_216_4_0,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("ComputeBBox",1096,G__G__Geom1_216_5_0,121,-1,-1,0,0,1,1,0,"",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("ComputeNormal",1350,G__G__Geom1_216_6_0,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__G__Geom1_216_7_0,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__G__Geom1_216_8_0,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_216_9_0,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__G__Geom1_216_0_1,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__G__Geom1_216_1_1,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__G__Geom1_216_2_1,121,-1,-1,0,1,1,1,8,"D - 'Double_t' 0 - param",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("GetByteCount",1213,G__G__Geom1_216_3_1,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_216_4_1,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_216_5_1,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_216_6_1,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_216_7_1,100,-1,G__defined_typename("Double_t"),0,0,1,1,8,"",(char*)NULL,(void*)NULL,0);
   G__memfunc_setup("GetFittingBox",1310,G__G__Geom1_216_8_1,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__G__Geom1_216_9_1,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__G__Geom1_216_0_2,105,-1,G__defined_typename("Int_t"),0,0,1,1,8,"",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("GetVisibleCorner",1623,G__G__Geom1_216_1_2,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_216_2_2,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__G__Geom1_216_3_2,121,-1,-1,0,0,1,1,8,"",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("IsCylType",902,G__G__Geom1_216_4_2,103,-1,G__defined_typename("Bool_t"),0,0,1,1,8,"",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("Safety",620,G__G__Geom1_216_5_2,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__G__Geom1_216_6_2,121,-1,-1,0,2,1,1,0,
"u 'basic_ofstream<char,char_traits<char> >' 'ofstream' 1 - out C - 'Option_t' 10 - option",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("SetDimensions",1349,G__G__Geom1_216_7_2,121,-1,-1,0,1,1,1,0,"D - 'Double_t' 0 - param",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("SetPoints",937,G__G__Geom1_216_8_2,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_216_9_2,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_216_0_3,121,-1,-1,0,1,1,1,8,"D - 'Double_t' 0 - vertex",(char*)NULL,(void*)NULL,0);
   G__memfunc_setup("Sizeof3D",743,G__G__Geom1_216_1_3,121,-1,-1,0,0,1,1,8,"",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("Class",502,G__G__Geom1_216_2_3,85,G__get_linked_tagnum(&G__G__Geom1LN_TClass),-1,0,0,3,1,0,"",(char*)NULL,(void*)(TClass* (*)())(&TGeoTrd1::Class),0);
   G__memfunc_setup("Class_Name",982,G__G__Geom1_216_3_3,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)(const char* (*)())(&TGeoTrd1::Class_Name),0);
   G__memfunc_setup("Class_Version",1339,G__G__Geom1_216_4_3,115,-1,G__defined_typename("Version_t"),0,0,3,1,0,"",(char*)NULL,(void*)(Version_t (*)())(&TGeoTrd1::Class_Version),0);
   G__memfunc_setup("Dictionary",1046,G__G__Geom1_216_5_3,121,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)(void (*)())(&TGeoTrd1::Dictionary),0);
   G__memfunc_setup("IsA",253,G__G__Geom1_216_6_3,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_216_7_3,121,-1,-1,0,2,1,1,0,
"u 'TMemberInspector' - 1 - insp C - - 0 - parent",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("Streamer",835,G__G__Geom1_216_8_3,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_9_3,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_4,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)(const char* (*)())(&TGeoTrd1::DeclFileName),0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Geom1_216_1_4,105,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)(int (*)())(&TGeoTrd1::ImplFileLine),0);
   G__memfunc_setup("ImplFileName",1171,G__G__Geom1_216_2_4,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)(const char* (*)())(&TGeoTrd1::ImplFileName),0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Geom1_216_3_4,105,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)(int (*)())(&TGeoTrd1::DeclFileLine),0);
   // automatic copy constructor
   G__memfunc_setup("TGeoTrd1",714,G__G__Geom1_216_4_4,(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_216_5_4,(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_216_6_4,(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_217_1_0,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_217_2_0,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_217_3_0,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_217_4_0,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("Contains",831,G__G__Geom1_217_5_0,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__G__Geom1_217_6_0,121,-1,-1,0,0,1,1,0,"",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("ComputeNormal",1350,G__G__Geom1_217_7_0,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__G__Geom1_217_8_0,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_217_9_0,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__G__Geom1_217_0_1,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__G__Geom1_217_1_1,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__G__Geom1_217_2_1,121,-1,-1,0,1,1,1,8,"D - 'Double_t' 0 - param",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("GetByteCount",1213,G__G__Geom1_217_3_1,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_217_4_1,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_217_5_1,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_217_6_1,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_217_7_1,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_217_8_1,100,-1,G__defined_typename("Double_t"),0,0,1,1,8,"",(char*)NULL,(void*)NULL,0);
   G__memfunc_setup("GetFittingBox",1310,G__G__Geom1_217_9_1,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__G__Geom1_217_0_2,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__G__Geom1_217_1_2,105,-1,G__defined_typename("Int_t"),0,0,1,1,8,"",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("GetVisibleCorner",1623,G__G__Geom1_217_2_2,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_217_3_2,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__G__Geom1_217_4_2,121,-1,-1,0,0,1,1,8,"",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("IsCylType",902,G__G__Geom1_217_5_2,103,-1,G__defined_typename("Bool_t"),0,0,1,1,8,"",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("Safety",620,G__G__Geom1_217_6_2,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__G__Geom1_217_7_2,121,-1,-1,0,2,1,1,0,
"u 'basic_ofstream<char,char_traits<char> >' 'ofstream' 1 - out C - 'Option_t' 10 - option",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("SetDimensions",1349,G__G__Geom1_217_8_2,121,-1,-1,0,1,1,1,0,"D - 'Double_t' 0 - param",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("SetPoints",937,G__G__Geom1_217_9_2,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_217_0_3,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_217_1_3,121,-1,-1,0,1,1,1,8,"D - 'Double_t' 0 - vertex",(char*)NULL,(void*)NULL,0);
   G__memfunc_setup("Sizeof3D",743,G__G__Geom1_217_2_3,121,-1,-1,0,0,1,1,8,"",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("Class",502,G__G__Geom1_217_3_3,85,G__get_linked_tagnum(&G__G__Geom1LN_TClass),-1,0,0,3,1,0,"",(char*)NULL,(void*)(TClass* (*)())(&TGeoTrd2::Class),0);
   G__memfunc_setup("Class_Name",982,G__G__Geom1_217_4_3,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)(const char* (*)())(&TGeoTrd2::Class_Name),0);
   G__memfunc_setup("Class_Version",1339,G__G__Geom1_217_5_3,115,-1,G__defined_typename("Version_t"),0,0,3,1,0,"",(char*)NULL,(void*)(Version_t (*)())(&TGeoTrd2::Class_Version),0);
   G__memfunc_setup("Dictionary",1046,G__G__Geom1_217_6_3,121,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)(void (*)())(&TGeoTrd2::Dictionary),0);
   G__memfunc_setup("IsA",253,G__G__Geom1_217_7_3,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_217_8_3,121,-1,-1,0,2,1,1,0,
"u 'TMemberInspector' - 1 - insp C - - 0 - parent",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("Streamer",835,G__G__Geom1_217_9_3,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_217_0_4,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_217_1_4,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)(const char* (*)())(&TGeoTrd2::DeclFileName),0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Geom1_217_2_4,105,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)(int (*)())(&TGeoTrd2::ImplFileLine),0);
   G__memfunc_setup("ImplFileName",1171,G__G__Geom1_217_3_4,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)(const char* (*)())(&TGeoTrd2::ImplFileName),0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Geom1_217_4_4,105,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)(int (*)())(&TGeoTrd2::DeclFileLine),0);
   // automatic copy constructor
   G__memfunc_setup("TGeoTrd2",715,G__G__Geom1_217_5_4,(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_217_6_4,(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_217_7_4,(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_memfuncTVirtualGeoTrack(void) {
   /* TVirtualGeoTrack */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Geom1LN_TVirtualGeoTrack));
   G__memfunc_setup("AddDaughter",1085,G__G__Geom1_310_3_0,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_310_4_0,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_310_5_0,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("GetId",461,G__G__Geom1_310_6_0,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_310_7_0,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_310_8_0,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_310_9_0,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_310_0_1,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__G__Geom1_310_1_1,67,-1,-1,0,0,1,1,9,"",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("GetNdaughters",1333,G__G__Geom1_310_2_1,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_310_3_1,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_310_4_1,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_310_5_1,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_310_6_1,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_310_7_1,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_310_8_1,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_310_9_1,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_310_0_2,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_310_1_2,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_310_2_2,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_310_3_2,103,-1,G__defined_typename("Bool_t"),0,0,1,1,8,"",(char*)NULL,(void*)NULL,0);
   G__memfunc_setup("Paint",508,G__G__Geom1_310_4_2,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_310_5_2,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_310_6_2,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_310_7_2,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_310_8_2,121,-1,-1,0,0,1,1,0,"",(char*)NULL,(void*)NULL,3);
   G__memfunc_setup("SetName",685,G__G__Geom1_310_9_2,121,-1,-1,0,1,1,1,0,"C - - 10 - name",(char*)NULL,(void*)NULL,0);
   G__memfunc_setup("SetParticle",1120,G__G__Geom1_310_0_3,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_310_1_3,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_310_2_3,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_310_3_3,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_310_4_3,85,G__get_linked_tagnum(&G__G__Geom1LN_TClass),-1,0,0,3,1,0,"",(char*)NULL,(void*)(TClass* (*)())(&TVirtualGeoTrack::Class),0);
   G__memfunc_setup("Class_Name",982,G__G__Geom1_310_5_3,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)(const char* (*)())(&TVirtualGeoTrack::Class_Name),0);
   G__memfunc_setup("Class_Version",1339,G__G__Geom1_310_6_3,115,-1,G__defined_typename("Version_t"),0,0,3,1,0,"",(char*)NULL,(void*)(Version_t (*)())(&TVirtualGeoTrack::Class_Version),0);
   G__memfunc_setup("Dictionary",1046,G__G__Geom1_310_7_3,121,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)(void (*)())(&TVirtualGeoTrack::Dictionary),0);
   G__memfunc_setup("IsA",253,G__G__Geom1_310_8_3,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_310_9_3,121,-1,-1,0,2,1,1,0,
"u 'TMemberInspector' - 1 - insp C - - 0 - parent",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("Streamer",835,G__G__Geom1_310_0_4,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_310_1_4,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_310_2_4,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)(const char* (*)())(&TVirtualGeoTrack::DeclFileName),0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Geom1_310_3_4,105,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)(int (*)())(&TVirtualGeoTrack::ImplFileLine),0);
   G__memfunc_setup("ImplFileName",1171,G__G__Geom1_310_4_4,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)(const char* (*)())(&TVirtualGeoTrack::ImplFileName),0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Geom1_310_5_4,105,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)(int (*)())(&TVirtualGeoTrack::DeclFileLine),0);
   // automatic destructor
   G__memfunc_setup("~TVirtualGeoTrack",1737,G__G__Geom1_310_6_4,(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_310_7_4,(int)('u'),G__get_linked_tagnum(&G__G__Geom1LN_TVirtualGeoTrack),-1,1,1,1,1,0,"u 'TVirtualGeoTrack' - 11 - -",(char*)NULL,(void*)NULL,0);
   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("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("TGeoPhysicalNode",1586,G__G__Geom1_311_2_0,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_311_3_0,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_311_4_0,121,-1,-1,0,3,1,1,0,
"U 'TGeoMatrix' - 0 0 newmat U 'TGeoShape' - 0 0 newshape "
"g - 'Bool_t' 0 kFALSE check",(char*)NULL,(void*)NULL,0);
   G__memfunc_setup("cd",199,G__G__Geom1_311_5_0,121,-1,-1,0,0,1,1,8,"",(char*)NULL,(void*)NULL,0);
   G__memfunc_setup("Draw",398,G__G__Geom1_311_6_0,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_311_7_0,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_311_8_0,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("GetMother",911,G__G__Geom1_311_9_0,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("GetName",673,G__G__Geom1_311_0_1,67,-1,-1,0,0,1,1,9,"",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("GetNode",678,G__G__Geom1_311_1_1,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_311_2_1,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_311_3_1,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_311_4_1,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_311_5_1,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_311_6_1,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_311_7_1,103,-1,G__defined_typename("Bool_t"),0,0,1,1,8,"",(char*)NULL,(void*)NULL,0);
   G__memfunc_setup("SetPath",697,G__G__Geom1_311_8_1,103,-1,G__defined_typename("Bool_t"),0,1,1,1,0,"C - - 10 - path",(char*)NULL,(void*)NULL,0);
   G__memfunc_setup("SetBranchAsState",1583,G__G__Geom1_311_9_1,121,-1,-1,0,0,1,1,0,"",(char*)NULL,(void*)NULL,0);
   G__memfunc_setup("SetIsVolAtt",1090,G__G__Geom1_311_0_2,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_311_1_2,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_311_2_2,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__G__Geom1_311_3_2,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_311_4_2,85,G__get_linked_tagnum(&G__G__Geom1LN_TClass),-1,0,0,3,1,0,"",(char*)NULL,(void*)(TClass* (*)())(&TGeoPhysicalNode::Class),0);
   G__memfunc_setup("Class_Name",982,G__G__Geom1_311_5_2,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)(const char* (*)())(&TGeoPhysicalNode::Class_Name),0);
   G__memfunc_setup("Class_Version",1339,G__G__Geom1_311_6_2,115,-1,G__defined_typename("Version_t"),0,0,3,1,0,"",(char*)NULL,(void*)(Version_t (*)())(&TGeoPhysicalNode::Class_Version),0);
   G__memfunc_setup("Dictionary",1046,G__G__Geom1_311_7_2,121,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)(void (*)())(&TGeoPhysicalNode::Dictionary),0);
   G__memfunc_setup("IsA",253,G__G__Geom1_311_8_2,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_311_9_2,121,-1,-1,0,2,1,1,0,
"u 'TMemberInspector' - 1 - insp C - - 0 - parent",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("Streamer",835,G__G__Geom1_311_0_3,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_311_1_3,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_311_2_3,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)(const char* (*)())(&TGeoPhysicalNode::DeclFileName),0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Geom1_311_3_3,105,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)(int (*)())(&TGeoPhysicalNode::ImplFileLine),0);
   G__memfunc_setup("ImplFileName",1171,G__G__Geom1_311_4_3,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)(const char* (*)())(&TGeoPhysicalNode::ImplFileName),0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Geom1_311_5_3,105,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)(int (*)())(&TGeoPhysicalNode::DeclFileLine),0);
   // automatic copy constructor
   G__memfunc_setup("TGeoPhysicalNode",1586,G__G__Geom1_311_6_3,(int)('i'),G__get_linked_tagnum(&G__G__Geom1LN_TGeoPhysicalNode),-1,0,1,1,1,0,"u 'TGeoPhysicalNode' - 11 - -",(char*)NULL,(void*)NULL,0);
   // automatic destructor
   G__memfunc_setup("~TGeoPhysicalNode",1712,G__G__Geom1_311_7_3,(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_311_8_3,(int)('u'),G__get_linked_tagnum(&G__G__Geom1LN_TGeoPhysicalNode),-1,1,1,1,1,0,"u 'TGeoPhysicalNode' - 11 - -",(char*)NULL,(void*)NULL,0);
   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_312_2_0,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_312_3_0,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_312_4_0,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_312_5_0,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_312_6_0,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("CheckGeometry",1322,G__G__Geom1_312_7_0,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_312_8_0,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_312_9_0,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_312_0_1,121,-1,-1,0,0,1,1,0,"",(char*)NULL,(void*)NULL,3);
   G__memfunc_setup("DefaultColors",1335,G__G__Geom1_312_1_1,121,-1,-1,0,0,1,1,0,"",(char*)NULL,(void*)NULL,3);
   G__memfunc_setup("DistanceToPrimitiveVol",2264,G__G__Geom1_312_2_1,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__G__Geom1_312_3_1,121,-1,-1,0,1,1,1,0,"C - 'Option_t' 10 \"\" option",(char*)NULL,(void*)NULL,3);
   G__memfunc_setup("DrawOnly",816,G__G__Geom1_312_4_1,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_312_5_1,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_312_6_1,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_312_7_1,121,-1,-1,0,0,1,1,0,"",(char*)NULL,(void*)NULL,3);
   G__memfunc_setup("DrawPath",795,G__G__Geom1_312_8_1,121,-1,-1,0,1,1,1,0,"C - - 10 - path",(char*)NULL,(void*)NULL,3);
   G__memfunc_setup("EstimateCameraMove",1820,G__G__Geom1_312_9_1,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("ExecuteVolumeEvent",1869,G__G__Geom1_312_0_2,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_312_1_2,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_312_2_2,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_312_3_2,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_312_4_2,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_312_5_2,67,-1,-1,0,0,1,1,9,"",(char*)NULL,(void*)NULL,3);
   G__memfunc_setup("GetDrawnVolume",1428,G__G__Geom1_312_6_2,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_312_7_2,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_312_8_2,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_312_9_2,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_312_0_3,67,-1,-1,0,3,1,1,8,
"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_312_1_3,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_312_2_3,68,-1,G__defined_typename("Double_t"),0,0,1,1,0,"",(char*)NULL,(void*)NULL,3);
   G__memfunc_setup("IsRaytracing",1232,G__G__Geom1_312_3_3,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_312_4_3,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_312_5_3,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_312_6_3,121,-1,-1,0,0,1,1,8,"",(char*)NULL,(void*)NULL,3);
   G__memfunc_setup("Paint",508,G__G__Geom1_312_7_3,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_312_8_3,121,-1,-1,0,2,1,1,0,
"U 'TGeoNode' - 0 - node C - 'Option_t' 10 \"\" option",(char*)NULL,(void*)NULL,3);
   G__memfunc_setup("PaintOverlap",1237,G__G__Geom1_312_9_3,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_312_0_4,121,-1,-1,0,0,1,1,8,"",(char*)NULL,(void*)NULL,3);
   G__memfunc_setup("RandomPoints",1246,G__G__Geom1_312_1_4,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_312_2_4,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_312_3_4,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_312_4_4,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_312_5_4,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_312_6_4,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_312_7_4,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_312_8_4,121,-1,-1,0,1,1,1,0,"U 'TGeoManager' - 0 - geom",(char*)NULL,(void*)NULL,3);
   G__memfunc_setup("SetNsegments",1248,G__G__Geom1_312_9_4,121,-1,-1,0,1,1,1,0,"i - 'Int_t' 0 20 nseg",(char*)NULL,(void*)NULL,3);
   G__memfunc_setup("SetRaytracing",1344,G__G__Geom1_312_0_5,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_312_1_5,85,G__get_linked_tagnum(&G__G__Geom1LN_TVirtualGeoPainter),-1,0,0,3,1,0,"",(char*)NULL,(void*)(TVirtualGeoPainter* (*)())(&TVirtualGeoPainter::GeoPainter),0);
   G__memfunc_setup("SetPainter",1023,G__G__Geom1_312_2_5,121,-1,-1,0,1,3,1,0,"U 'TVirtualGeoPainter' - 10 - painter",(char*)NULL,(void*)(void (*)(const TVirtualGeoPainter*))(&TVirtualGeoPainter::SetPainter),0);
   G__memfunc_setup("SetTopVisible",1325,G__G__Geom1_312_3_5,121,-1,-1,0,1,1,1,0,"g - 'Bool_t' 0 kTRUE vis",(char*)NULL,(void*)NULL,3);
   G__memfunc_setup("SetVisLevel",1110,G__G__Geom1_312_4_5,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_312_5_5,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_312_6_5,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_312_7_5,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_312_8_5,121,-1,-1,0,1,1,1,0,"C - - 10 - path",(char*)NULL,(void*)NULL,3);
   G__memfunc_setup("TestVoxels",1057,G__G__Geom1_312_9_5,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_312_0_6,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_312_1_6,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_312_2_6,85,G__get_linked_tagnum(&G__G__Geom1LN_TClass),-1,0,0,3,1,0,"",(char*)NULL,(void*)(TClass* (*)())(&TVirtualGeoPainter::Class),0);
   G__memfunc_setup("Class_Name",982,G__G__Geom1_312_3_6,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)(const char* (*)())(&TVirtualGeoPainter::Class_Name),0);
   G__memfunc_setup("Class_Version",1339,G__G__Geom1_312_4_6,115,-1,G__defined_typename("Version_t"),0,0,3,1,0,"",(char*)NULL,(void*)(Version_t (*)())(&TVirtualGeoPainter::Class_Version),0);
   G__memfunc_setup("Dictionary",1046,G__G__Geom1_312_5_6,121,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)(void (*)())(&TVirtualGeoPainter::Dictionary),0);
   G__memfunc_setup("IsA",253,G__G__Geom1_312_6_6,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_312_7_6,121,-1,-1,0,2,1,1,0,
"u 'TMemberInspector' - 1 - insp C - - 0 - parent",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("Streamer",835,G__G__Geom1_312_8_6,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_312_9_6,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_312_0_7,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)(const char* (*)())(&TVirtualGeoPainter::DeclFileName),0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Geom1_312_1_7,105,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)(int (*)())(&TVirtualGeoPainter::ImplFileLine),0);
   G__memfunc_setup("ImplFileName",1171,G__G__Geom1_312_2_7,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)(const char* (*)())(&TVirtualGeoPainter::ImplFileName),0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Geom1_312_3_7,105,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)(int (*)())(&TVirtualGeoPainter::DeclFileLine),0);
   // automatic destructor
   G__memfunc_setup("~TVirtualGeoPainter",1959,G__G__Geom1_312_4_7,(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_312_5_7,(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__G__Geom1_313_1_0,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_313_2_0,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_313_3_0,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_313_4_0,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("ComputeBBox",1096,G__G__Geom1_313_5_0,121,-1,-1,0,0,1,1,0,"",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("ComputeNormal",1350,G__G__Geom1_313_6_0,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__G__Geom1_313_7_0,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__G__Geom1_313_8_0,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_313_9_0,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__G__Geom1_313_0_1,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_313_1_1,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__G__Geom1_313_2_1,121,-1,-1,0,1,1,1,8,"D - 'Double_t' 0 - -",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("GetMakeRuntimeShape",1907,G__G__Geom1_313_3_1,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__G__Geom1_313_4_1,105,-1,G__defined_typename("Int_t"),0,0,1,1,8,"",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("InspectShape",1223,G__G__Geom1_313_5_1,121,-1,-1,0,0,1,1,8,"",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("IsComposite",1135,G__G__Geom1_313_6_1,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_313_7_1,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_313_8_1,121,-1,-1,0,1,1,1,0,"C - - 10 - expression",(char*)NULL,(void*)NULL,0);
   G__memfunc_setup("PaintComposite",1455,G__G__Geom1_313_9_1,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("Safety",620,G__G__Geom1_313_0_2,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__G__Geom1_313_1_2,121,-1,-1,0,2,1,1,0,
"u 'basic_ofstream<char,char_traits<char> >' 'ofstream' 1 - out C - 'Option_t' 10 - option",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("SetDimensions",1349,G__G__Geom1_313_2_2,121,-1,-1,0,1,1,1,0,"D - 'Double_t' 0 - -",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("SetPoints",937,G__G__Geom1_313_3_2,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_313_4_2,121,-1,-1,0,1,1,1,8,"F - 'Float_t' 0 - points",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("Sizeof3D",743,G__G__Geom1_313_5_2,121,-1,-1,0,0,1,1,8,"",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("Class",502,G__G__Geom1_313_6_2,85,G__get_linked_tagnum(&G__G__Geom1LN_TClass),-1,0,0,3,1,0,"",(char*)NULL,(void*)(TClass* (*)())(&TGeoCompositeShape::Class),0);
   G__memfunc_setup("Class_Name",982,G__G__Geom1_313_7_2,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)(const char* (*)())(&TGeoCompositeShape::Class_Name),0);
   G__memfunc_setup("Class_Version",1339,G__G__Geom1_313_8_2,115,-1,G__defined_typename("Version_t"),0,0,3,1,0,"",(char*)NULL,(void*)(Version_t (*)())(&TGeoCompositeShape::Class_Version),0);
   G__memfunc_setup("Dictionary",1046,G__G__Geom1_313_9_2,121,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)(void (*)())(&TGeoCompositeShape::Dictionary),0);
   G__memfunc_setup("IsA",253,G__G__Geom1_313_0_3,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_313_1_3,121,-1,-1,0,2,1,1,0,
"u 'TMemberInspector' - 1 - insp C - - 0 - parent",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("Streamer",835,G__G__Geom1_313_2_3,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_313_3_3,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_313_4_3,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)(const char* (*)())(&TGeoCompositeShape::DeclFileName),0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Geom1_313_5_3,105,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)(int (*)())(&TGeoCompositeShape::ImplFileLine),0);
   G__memfunc_setup("ImplFileName",1171,G__G__Geom1_313_6_3,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)(const char* (*)())(&TGeoCompositeShape::ImplFileName),0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Geom1_313_7_3,105,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)(int (*)())(&TGeoCompositeShape::DeclFileLine),0);
   // automatic copy constructor
   G__memfunc_setup("TGeoCompositeShape",1811,G__G__Geom1_313_8_3,(int)('i'),G__get_linked_tagnum(&G__G__Geom1LN_TGeoCompositeShape),-1,0,1,1,1,0,"u 'TGeoCompositeShape' - 11 - -",(char*)NULL,(void*)NULL,0);
   // automatic destructor
   G__memfunc_setup("~TGeoCompositeShape",1937,G__G__Geom1_313_9_3,(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_313_0_4,(int)('u'),G__get_linked_tagnum(&G__G__Geom1LN_TGeoCompositeShape),-1,1,1,1,1,0,"u 'TGeoCompositeShape' - 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_319_5_0,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_319_6_0,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("Contains",831,G__G__Geom1_319_7_0,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_319_8_0,121,-1,-1,0,0,1,1,0,"",(char*)NULL,(void*)NULL,0);
   G__memfunc_setup("GetNvert",815,G__G__Geom1_319_9_0,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_319_0_1,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_319_1_1,68,-1,G__defined_typename("Double_t"),0,0,1,1,0,"",(char*)NULL,(void*)NULL,0);
   G__memfunc_setup("IsConvex",815,G__G__Geom1_319_2_1,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_319_3_1,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_319_4_1,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_319_5_1,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_319_6_1,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_319_7_1,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_319_8_1,85,G__get_linked_tagnum(&G__G__Geom1LN_TClass),-1,0,0,3,1,0,"",(char*)NULL,(void*)(TClass* (*)())(&TGeoPolygon::Class),0);
   G__memfunc_setup("Class_Name",982,G__G__Geom1_319_9_1,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)(const char* (*)())(&TGeoPolygon::Class_Name),0);
   G__memfunc_setup("Class_Version",1339,G__G__Geom1_319_0_2,115,-1,G__defined_typename("Version_t"),0,0,3,1,0,"",(char*)NULL,(void*)(Version_t (*)())(&TGeoPolygon::Class_Version),0);
   G__memfunc_setup("Dictionary",1046,G__G__Geom1_319_1_2,121,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)(void (*)())(&TGeoPolygon::Dictionary),0);
   G__memfunc_setup("IsA",253,G__G__Geom1_319_2_2,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_319_3_2,121,-1,-1,0,2,1,1,0,
"u 'TMemberInspector' - 1 - insp C - - 0 - parent",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("Streamer",835,G__G__Geom1_319_4_2,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_319_5_2,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_319_6_2,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)(const char* (*)())(&TGeoPolygon::DeclFileName),0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Geom1_319_7_2,105,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)(int (*)())(&TGeoPolygon::ImplFileLine),0);
   G__memfunc_setup("ImplFileName",1171,G__G__Geom1_319_8_2,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)(const char* (*)())(&TGeoPolygon::ImplFileName),0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Geom1_319_9_2,105,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)(int (*)())(&TGeoPolygon::DeclFileLine),0);
   // automatic copy constructor
   G__memfunc_setup("TGeoPolygon",1111,G__G__Geom1_319_0_3,(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_319_1_3,(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_319_2_3,(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("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_321_8_0,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_321_9_0,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_321_0_1,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("ComputeBBox",1096,G__G__Geom1_321_1_1,121,-1,-1,0,0,1,1,0,"",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("ComputeNormal",1350,G__G__Geom1_321_2_1,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__G__Geom1_321_3_1,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_321_4_1,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_321_5_1,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__G__Geom1_321_6_1,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_321_7_1,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__G__Geom1_321_8_1,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__G__Geom1_321_9_1,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_321_0_2,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_321_1_2,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_321_2_2,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_321_3_2,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_321_4_2,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_321_5_2,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_321_6_2,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_321_7_2,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_321_8_2,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__G__Geom1_321_9_2,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__G__Geom1_321_0_3,105,-1,G__defined_typename("Int_t"),0,0,1,1,8,"",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("InspectShape",1223,G__G__Geom1_321_1_3,121,-1,-1,0,0,1,1,8,"",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("MakeBuffer3D",1103,G__G__Geom1_321_2_3,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_321_3_3,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__G__Geom1_321_4_3,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__G__Geom1_321_5_3,121,-1,-1,0,2,1,1,0,
"u 'basic_ofstream<char,char_traits<char> >' 'ofstream' 1 - out C - 'Option_t' 10 - option",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("SetCurrentZ",1129,G__G__Geom1_321_6_3,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_321_7_3,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__G__Geom1_321_8_3,121,-1,-1,0,1,1,1,0,"D - 'Double_t' 0 - param",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("SetPoints",937,G__G__Geom1_321_9_3,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_321_0_4,121,-1,-1,0,1,1,1,8,"F - 'Float_t' 0 - points",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("SetSegsAndPols",1391,G__G__Geom1_321_1_4,121,-1,-1,0,1,1,1,8,"u 'TBuffer3D' - 1 - buff",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("Sizeof3D",743,G__G__Geom1_321_2_4,121,-1,-1,0,0,1,1,8,"",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("Class",502,G__G__Geom1_321_3_4,85,G__get_linked_tagnum(&G__G__Geom1LN_TClass),-1,0,0,3,1,0,"",(char*)NULL,(void*)(TClass* (*)())(&TGeoXtru::Class),0);
   G__memfunc_setup("Class_Name",982,G__G__Geom1_321_4_4,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)(const char* (*)())(&TGeoXtru::Class_Name),0);
   G__memfunc_setup("Class_Version",1339,G__G__Geom1_321_5_4,115,-1,G__defined_typename("Version_t"),0,0,3,1,0,"",(char*)NULL,(void*)(Version_t (*)())(&TGeoXtru::Class_Version),0);
   G__memfunc_setup("Dictionary",1046,G__G__Geom1_321_6_4,121,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)(void (*)())(&TGeoXtru::Dictionary),0);
   G__memfunc_setup("IsA",253,G__G__Geom1_321_7_4,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_321_8_4,121,-1,-1,0,2,1,1,0,
"u 'TMemberInspector' - 1 - insp C - - 0 - parent",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("Streamer",835,G__G__Geom1_321_9_4,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_321_0_5,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_321_1_5,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)(const char* (*)())(&TGeoXtru::DeclFileName),0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Geom1_321_2_5,105,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)(int (*)())(&TGeoXtru::ImplFileLine),0);
   G__memfunc_setup("ImplFileName",1171,G__G__Geom1_321_3_5,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)(const char* (*)())(&TGeoXtru::ImplFileName),0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Geom1_321_4_5,105,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)(int (*)())(&TGeoXtru::DeclFileLine),0);
   // automatic copy constructor
   G__memfunc_setup("TGeoXtru",802,G__G__Geom1_321_5_5,(int)('i'),G__get_linked_tagnum(&G__G__Geom1LN_TGeoXtru),-1,0,1,1,1,0,"u 'TGeoXtru' - 11 - -",(char*)NULL,(void*)NULL,0);
   // automatic destructor
   G__memfunc_setup("~TGeoXtru",928,G__G__Geom1_321_6_5,(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_321_7_5,(int)('u'),G__get_linked_tagnum(&G__G__Geom1LN_TGeoXtru),-1,1,1,1,1,0,"u 'TGeoXtru' - 11 - -",(char*)NULL,(void*)NULL,0);
   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_323_1_0,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_323_2_0,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_323_3_0,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_323_4_0,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_323_5_0,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_323_6_0,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_323_7_0,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_323_8_0,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_323_9_0,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_323_0_1,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_323_1_1,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_323_2_1,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_323_3_1,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_323_4_1,121,-1,-1,0,0,1,1,0,"",(char*)NULL,(void*)NULL,0);
   G__memfunc_setup("StepToPlane",1103,G__G__Geom1_323_5_1,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_323_6_1,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_323_7_1,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_323_8_1,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_323_9_1,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_323_0_2,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_323_1_2,121,-1,-1,0,0,1,1,0,"",(char*)NULL,(void*)NULL,0);
   G__memfunc_setup("Class",502,G__G__Geom1_323_2_2,85,G__get_linked_tagnum(&G__G__Geom1LN_TClass),-1,0,0,3,1,0,"",(char*)NULL,(void*)(TClass* (*)())(&TGeoHelix::Class),0);
   G__memfunc_setup("Class_Name",982,G__G__Geom1_323_3_2,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)(const char* (*)())(&TGeoHelix::Class_Name),0);
   G__memfunc_setup("Class_Version",1339,G__G__Geom1_323_4_2,115,-1,G__defined_typename("Version_t"),0,0,3,1,0,"",(char*)NULL,(void*)(Version_t (*)())(&TGeoHelix::Class_Version),0);
   G__memfunc_setup("Dictionary",1046,G__G__Geom1_323_5_2,121,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)(void (*)())(&TGeoHelix::Dictionary),0);
   G__memfunc_setup("IsA",253,G__G__Geom1_323_6_2,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_323_7_2,121,-1,-1,0,2,1,1,0,
"u 'TMemberInspector' - 1 - insp C - - 0 - parent",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("Streamer",835,G__G__Geom1_323_8_2,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_323_9_2,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_323_0_3,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)(const char* (*)())(&TGeoHelix::DeclFileName),0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Geom1_323_1_3,105,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)(int (*)())(&TGeoHelix::ImplFileLine),0);
   G__memfunc_setup("ImplFileName",1171,G__G__Geom1_323_2_3,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)(const char* (*)())(&TGeoHelix::ImplFileName),0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Geom1_323_3_3,105,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)(int (*)())(&TGeoHelix::DeclFileLine),0);
   // automatic copy constructor
   G__memfunc_setup("TGeoHelix",873,G__G__Geom1_323_4_3,(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_323_5_3,(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_323_6_3,(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_325_1_0,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_325_2_0,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_325_3_0,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_325_4_0,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("ComputeBBox",1096,G__G__Geom1_325_5_0,121,-1,-1,0,0,1,1,0,"",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("ComputeNormal",1350,G__G__Geom1_325_6_0,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__G__Geom1_325_7_0,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__G__Geom1_325_8_0,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_325_9_0,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__G__Geom1_325_0_1,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_325_1_1,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__G__Geom1_325_2_1,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__G__Geom1_325_3_1,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_325_4_1,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_325_5_1,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_325_6_1,100,-1,G__defined_typename("Double_t"),0,0,1,1,8,"",(char*)NULL,(void*)NULL,0);
   G__memfunc_setup("GetBoundingCylinder",1936,G__G__Geom1_325_7_1,121,-1,-1,0,1,1,1,8,"D - 'Double_t' 0 - param",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("GetMakeRuntimeShape",1907,G__G__Geom1_325_8_1,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__G__Geom1_325_9_1,105,-1,G__defined_typename("Int_t"),0,0,1,1,8,"",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("InspectShape",1223,G__G__Geom1_325_0_2,121,-1,-1,0,0,1,1,8,"",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("IsCylType",902,G__G__Geom1_325_1_2,103,-1,G__defined_typename("Bool_t"),0,0,1,1,8,"",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("MakeBuffer3D",1103,G__G__Geom1_325_2_2,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__G__Geom1_325_3_2,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__G__Geom1_325_4_2,121,-1,-1,0,2,1,1,0,
"u 'basic_ofstream<char,char_traits<char> >' 'ofstream' 1 - out C - 'Option_t' 10 - option",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("SetParaboloidDimensions",2370,G__G__Geom1_325_5_2,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__G__Geom1_325_6_2,121,-1,-1,0,1,1,1,0,"D - 'Double_t' 0 - param",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("SetPoints",937,G__G__Geom1_325_7_2,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_325_8_2,121,-1,-1,0,1,1,1,8,"F - 'Float_t' 0 - points",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("SetSegsAndPols",1391,G__G__Geom1_325_9_2,121,-1,-1,0,1,1,1,8,"u 'TBuffer3D' - 1 - buff",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("Sizeof3D",743,G__G__Geom1_325_0_3,121,-1,-1,0,0,1,1,8,"",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("Class",502,G__G__Geom1_325_1_3,85,G__get_linked_tagnum(&G__G__Geom1LN_TClass),-1,0,0,3,1,0,"",(char*)NULL,(void*)(TClass* (*)())(&TGeoParaboloid::Class),0);
   G__memfunc_setup("Class_Name",982,G__G__Geom1_325_2_3,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)(const char* (*)())(&TGeoParaboloid::Class_Name),0);
   G__memfunc_setup("Class_Version",1339,G__G__Geom1_325_3_3,115,-1,G__defined_typename("Version_t"),0,0,3,1,0,"",(char*)NULL,(void*)(Version_t (*)())(&TGeoParaboloid::Class_Version),0);
   G__memfunc_setup("Dictionary",1046,G__G__Geom1_325_4_3,121,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)(void (*)())(&TGeoParaboloid::Dictionary),0);
   G__memfunc_setup("IsA",253,G__G__Geom1_325_5_3,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_325_6_3,121,-1,-1,0,2,1,1,0,
"u 'TMemberInspector' - 1 - insp C - - 0 - parent",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("Streamer",835,G__G__Geom1_325_7_3,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_325_8_3,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_325_9_3,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)(const char* (*)())(&TGeoParaboloid::DeclFileName),0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Geom1_325_0_4,105,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)(int (*)())(&TGeoParaboloid::ImplFileLine),0);
   G__memfunc_setup("ImplFileName",1171,G__G__Geom1_325_1_4,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)(const char* (*)())(&TGeoParaboloid::ImplFileName),0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Geom1_325_2_4,105,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)(int (*)())(&TGeoParaboloid::DeclFileLine),0);
   // automatic copy constructor
   G__memfunc_setup("TGeoParaboloid",1388,G__G__Geom1_325_3_4,(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_325_4_4,(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_325_5_4,(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_326_1_0,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_326_2_0,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_326_3_0,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("ComputeBBox",1096,G__G__Geom1_326_4_0,121,-1,-1,0,0,1,1,0,"",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("ComputeNormal",1350,G__G__Geom1_326_5_0,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__G__Geom1_326_6_0,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__G__Geom1_326_7_0,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__G__Geom1_326_8_0,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_326_9_0,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__G__Geom1_326_0_1,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_326_1_1,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_326_2_1,68,-1,G__defined_typename("Double_t"),0,0,1,1,0,"",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("GetBoundingCylinder",1936,G__G__Geom1_326_3_1,121,-1,-1,0,1,1,1,8,"D - 'Double_t' 0 - -",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("GetMakeRuntimeShape",1907,G__G__Geom1_326_4_1,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__G__Geom1_326_5_1,105,-1,G__defined_typename("Int_t"),0,0,1,1,8,"",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("InspectShape",1223,G__G__Geom1_326_6_1,121,-1,-1,0,0,1,1,8,"",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("IsCylType",902,G__G__Geom1_326_7_1,103,-1,G__defined_typename("Bool_t"),0,0,1,1,8,"",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("Safety",620,G__G__Geom1_326_8_1,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__G__Geom1_326_9_1,121,-1,-1,0,2,1,1,0,
"u 'basic_ofstream<char,char_traits<char> >' 'ofstream' 1 - out C - 'Option_t' 10 - option",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("SetDimensions",1349,G__G__Geom1_326_0_2,121,-1,-1,0,1,1,1,0,"D - 'Double_t' 0 - param",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("SetPoints",937,G__G__Geom1_326_1_2,121,-1,-1,0,1,1,1,8,"D - 'Double_t' 0 - -",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("SetPoints",937,G__G__Geom1_326_2_2,121,-1,-1,0,1,1,1,8,"F - 'Float_t' 0 - -",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("Sizeof3D",743,G__G__Geom1_326_3_2,121,-1,-1,0,0,1,1,8,"",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("Class",502,G__G__Geom1_326_4_2,85,G__get_linked_tagnum(&G__G__Geom1LN_TClass),-1,0,0,3,1,0,"",(char*)NULL,(void*)(TClass* (*)())(&TGeoHalfSpace::Class),0);
   G__memfunc_setup("Class_Name",982,G__G__Geom1_326_5_2,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)(const char* (*)())(&TGeoHalfSpace::Class_Name),0);
   G__memfunc_setup("Class_Version",1339,G__G__Geom1_326_6_2,115,-1,G__defined_typename("Version_t"),0,0,3,1,0,"",(char*)NULL,(void*)(Version_t (*)())(&TGeoHalfSpace::Class_Version),0);
   G__memfunc_setup("Dictionary",1046,G__G__Geom1_326_7_2,121,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)(void (*)())(&TGeoHalfSpace::Dictionary),0);
   G__memfunc_setup("IsA",253,G__G__Geom1_326_8_2,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_326_9_2,121,-1,-1,0,2,1,1,0,
"u 'TMemberInspector' - 1 - insp C - - 0 - parent",(char*)NULL,(void*)NULL,1);
   G__memfunc_setup("Streamer",835,G__G__Geom1_326_0_3,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_326_1_3,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_326_2_3,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)(const char* (*)())(&TGeoHalfSpace::DeclFileName),0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Geom1_326_3_3,105,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)(int (*)())(&TGeoHalfSpace::ImplFileLine),0);
   G__memfunc_setup("ImplFileName",1171,G__G__Geom1_326_4_3,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)(const char* (*)())(&TGeoHalfSpace::ImplFileName),0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Geom1_326_5_3,105,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)(int (*)())(&TGeoHalfSpace::DeclFileLine),0);
   // automatic copy constructor
   G__memfunc_setup("TGeoHalfSpace",1238,G__G__Geom1_326_6_3,(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_326_7_3,(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_326_8_3,(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();
}


/*********************************************************
* 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);
}

static void G__cpp_setup_global3() {
}

static void G__cpp_setup_global4() {
   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();
  G__cpp_setup_global3();
  G__cpp_setup_global4();
}

/*********************************************************
* Global function information setup for each class
*********************************************************/
static void G__cpp_setup_func0() {
   G__lastifuncposition();

}

static void G__cpp_setup_func1() {
}

static void G__cpp_setup_func2() {
}

static void G__cpp_setup_func3() {
}

static void G__cpp_setup_func4() {
}

static void G__cpp_setup_func5() {

   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();
  G__cpp_setup_func4();
  G__cpp_setup_func5();
}

/*********************************************************
* 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_basic_ofstreamlEcharcOchar_traitslEchargRsPgR = { "basic_ofstream<char,char_traits<char> >" , 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_vectorlETStreamerInfomUcOallocatorlETStreamerInfomUgRsPgR = { "vector<TStreamerInfo*,allocator<TStreamerInfo*> >" , 99 , -1 };
G__linked_taginfo G__G__Geom1LN_reverse_iteratorlEvectorlETStreamerInfomUcOallocatorlETStreamerInfomUgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<TStreamerInfo*,allocator<TStreamerInfo*> >::iterator>" , 99 , -1 };
G__linked_taginfo G__G__Geom1LN_TString = { "TString" , 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_TGeoElementTable = { "TGeoElementTable" , 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_TGeoMaterial = { "TGeoMaterial" , 99 , -1 };
G__linked_taginfo G__G__Geom1LN_TGeoMaterialcLcLEGeoMaterial = { "TGeoMaterial::EGeoMaterial" , 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_TAttLine = { "TAttLine" , 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_TGeoVoxelFinder = { "TGeoVoxelFinder" , 99 , -1 };
G__linked_taginfo G__G__Geom1LN_TGeoPatternFinder = { "TGeoPatternFinder" , 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_TGeoVoxelFindercLcLEVoxelsType = { "TGeoVoxelFinder::EVoxelsType" , 101 , -1 };
G__linked_taginfo G__G__Geom1LN_TGeoCylVoxels = { "TGeoCylVoxels" , 99 , -1 };
G__linked_taginfo G__G__Geom1LN_TGeoFullVoxels = { "TGeoFullVoxels" , 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_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_vectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgR = { "vector<unsigned int,allocator<unsigned int> >" , 99 , -1 };
G__linked_taginfo G__G__Geom1LN_reverse_iteratorlEvectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<unsigned int,allocator<unsigned int> >::iterator>" , 99 , -1 };
G__linked_taginfo G__G__Geom1LN_vectorlETStringcOallocatorlETStringgRsPgR = { "vector<TString,allocator<TString> >" , 99 , -1 };
G__linked_taginfo G__G__Geom1LN_reverse_iteratorlEvectorlETStringcOallocatorlETStringgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<TString,allocator<TString> >::iterator>" , 99 , -1 };
G__linked_taginfo G__G__Geom1LN_TGeoNodeCache = { "TGeoNodeCache" , 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_TVirtualGeoPainter = { "TVirtualGeoPainter" , 99 , -1 };
G__linked_taginfo G__G__Geom1LN_TGeoCompositeShape = { "TGeoCompositeShape" , 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_TAttMarker = { "TAttMarker" , 99 , -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_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 };

/* 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_basic_ofstreamlEcharcOchar_traitslEchargRsPgR.tagnum = -1 ;
  G__G__Geom1LN_TList.tagnum = -1 ;
  G__G__Geom1LN_TBrowser.tagnum = -1 ;
  G__G__Geom1LN_TObjArray.tagnum = -1 ;
  G__G__Geom1LN_vectorlETStreamerInfomUcOallocatorlETStreamerInfomUgRsPgR.tagnum = -1 ;
  G__G__Geom1LN_reverse_iteratorlEvectorlETStreamerInfomUcOallocatorlETStreamerInfomUgRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__G__Geom1LN_TString.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_TGeoElementTable.tagnum = -1 ;
  G__G__Geom1LN_TGeoElement.tagnum = -1 ;
  G__G__Geom1LN_TGeoElementcLcLEGeoElement.tagnum = -1 ;
  G__G__Geom1LN_TGeoMaterial.tagnum = -1 ;
  G__G__Geom1LN_TGeoMaterialcLcLEGeoMaterial.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_TAttLine.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_TGeoVoxelFinder.tagnum = -1 ;
  G__G__Geom1LN_TGeoPatternFinder.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_TGeoVoxelFindercLcLEVoxelsType.tagnum = -1 ;
  G__G__Geom1LN_TGeoCylVoxels.tagnum = -1 ;
  G__G__Geom1LN_TGeoFullVoxels.tagnum = -1 ;
  G__G__Geom1LN_TGeoNodecLcLdA.tagnum = -1 ;
  G__G__Geom1LN_TGeoNodeMatrix.tagnum = -1 ;
  G__G__Geom1LN_TGeoNodeOffset.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_vectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgR.tagnum = -1 ;
  G__G__Geom1LN_reverse_iteratorlEvectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__G__Geom1LN_vectorlETStringcOallocatorlETStringgRsPgR.tagnum = -1 ;
  G__G__Geom1LN_reverse_iteratorlEvectorlETStringcOallocatorlETStringgRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__G__Geom1LN_TGeoNodeCache.tagnum = -1 ;
  G__G__Geom1LN_TVirtualGeoTrack.tagnum = -1 ;
  G__G__Geom1LN_TGeoPhysicalNode.tagnum = -1 ;
  G__G__Geom1LN_TVirtualGeoPainter.tagnum = -1 ;
  G__G__Geom1LN_TGeoCompositeShape.tagnum = -1 ;
  G__G__Geom1LN_TVirtualGeoPaintercLcLEGeoVisLevel.tagnum = -1 ;
  G__G__Geom1LN_TVirtualGeoPaintercLcLEGeoVisOption.tagnum = -1 ;
  G__G__Geom1LN_TVirtualGeoPaintercLcLEGeoBombOption.tagnum = -1 ;
  G__G__Geom1LN_TAttMarker.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_TGeoHelix.tagnum = -1 ;
  G__G__Geom1LN_TGeoHelixcLcLEGeoHelixTypes.tagnum = -1 ;
  G__G__Geom1LN_TGeoParaboloid.tagnum = -1 ;
  G__G__Geom1LN_TGeoHalfSpace.tagnum = -1 ;
}


extern "C" void G__cpp_setup_tagtableG__Geom1() {

   /* Setting up class,struct,union tag entry */
   G__get_linked_tagnum(&G__G__Geom1LN_TClass);
   G__get_linked_tagnum(&G__G__Geom1LN_TBuffer);
   G__get_linked_tagnum(&G__G__Geom1LN_TMemberInspector);
   G__get_linked_tagnum(&G__G__Geom1LN_TObject);
   G__get_linked_tagnum(&G__G__Geom1LN_TNamed);
   G__get_linked_tagnum(&G__G__Geom1LN_basic_ofstreamlEcharcOchar_traitslEchargRsPgR);
   G__get_linked_tagnum(&G__G__Geom1LN_TList);
   G__get_linked_tagnum(&G__G__Geom1LN_TBrowser);
   G__get_linked_tagnum(&G__G__Geom1LN_TObjArray);
   G__get_linked_tagnum(&G__G__Geom1LN_vectorlETStreamerInfomUcOallocatorlETStreamerInfomUgRsPgR);
   G__get_linked_tagnum(&G__G__Geom1LN_reverse_iteratorlEvectorlETStreamerInfomUcOallocatorlETStreamerInfomUgRsPgRcLcLiteratorgR);
   G__get_linked_tagnum(&G__G__Geom1LN_TString);
   G__tagtable_setup(G__get_linked_tagnum(&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(&G__G__Geom1LN_TGeoAttcLcLdA);
   G__get_linked_tagnum(&G__G__Geom1LN_TGeoAttcLcLEGeoVisibilityAtt);
   G__get_linked_tagnum(&G__G__Geom1LN_TGeoAttcLcLEGeoActivityAtt);
   G__get_linked_tagnum(&G__G__Geom1LN_TGeoAttcLcLEGeoOptimizationAtt);
   G__get_linked_tagnum(&G__G__Geom1LN_TGeoAttcLcLEGeoSavePrimitiveAtt);
   G__tagtable_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoShape),sizeof(TGeoShape),-1,324887,"base class for shapes",G__setup_memvarTGeoShape,G__setup_memfuncTGeoShape);
   G__tagtable_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoMatrix),sizeof(TGeoMatrix),-1,327428,"base geometrical transformation class",G__setup_memvarTGeoMatrix,G__setup_memfuncTGeoMatrix);
   G__tagtable_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoHMatrix),sizeof(TGeoHMatrix),-1,326912,"global matrix class",G__setup_memvarTGeoHMatrix,G__setup_memfuncTGeoHMatrix);
   G__tagtable_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoBoolNode),sizeof(TGeoBoolNode),-1,324875,"a boolean node",G__setup_memvarTGeoBoolNode,G__setup_memfuncTGeoBoolNode);
   G__get_linked_tagnum(&G__G__Geom1LN_TGeoBoolNodecLcLEGeoBoolType);
   G__tagtable_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoUnion),sizeof(TGeoUnion),-1,324864,"union node",G__setup_memvarTGeoUnion,G__setup_memfuncTGeoUnion);
   G__tagtable_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoIntersection),sizeof(TGeoIntersection),-1,324864,"intersection node",G__setup_memvarTGeoIntersection,G__setup_memfuncTGeoIntersection);
   G__tagtable_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoSubtraction),sizeof(TGeoSubtraction),-1,324864,"subtraction node",G__setup_memvarTGeoSubtraction,G__setup_memfuncTGeoSubtraction);
   G__get_linked_tagnum(&G__G__Geom1LN_TAttFill);
   G__tagtable_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoElementTable),sizeof(TGeoElementTable),-1,324864,"table of elements",G__setup_memvarTGeoElementTable,G__setup_memfuncTGeoElementTable);
   G__tagtable_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoElement),sizeof(TGeoElement),-1,324864,"base element class",G__setup_memvarTGeoElement,G__setup_memfuncTGeoElement);
   G__get_linked_tagnum(&G__G__Geom1LN_TGeoElementcLcLEGeoElement);
   G__tagtable_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoMaterial),sizeof(TGeoMaterial),-1,324864,"base material class",G__setup_memvarTGeoMaterial,G__setup_memfuncTGeoMaterial);
   G__get_linked_tagnum(&G__G__Geom1LN_TGeoMaterialcLcLEGeoMaterial);
   G__tagtable_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoMixture),sizeof(TGeoMixture),-1,324864,"material mixtures",G__setup_memvarTGeoMixture,G__setup_memfuncTGeoMixture);
   G__tagtable_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoMedium),sizeof(TGeoMedium),-1,324864,"tracking medium",G__setup_memvarTGeoMedium,G__setup_memfuncTGeoMedium);
   G__get_linked_tagnum(&G__G__Geom1LN_TGeoMediumcLcLEGeoMedium);
   G__get_linked_tagnum(&G__G__Geom1LN_TGeoMatrixcLcLEGeoTransfTypes);
   G__tagtable_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoTranslation),sizeof(TGeoTranslation),-1,327424,"translation class",G__setup_memvarTGeoTranslation,G__setup_memfuncTGeoTranslation);
   G__tagtable_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoRotation),sizeof(TGeoRotation),-1,327424,"rotation class",G__setup_memvarTGeoRotation,G__setup_memfuncTGeoRotation);
   G__tagtable_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoScale),sizeof(TGeoScale),-1,325376,"scaling class",G__setup_memvarTGeoScale,G__setup_memfuncTGeoScale);
   G__tagtable_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoCombiTrans),sizeof(TGeoCombiTrans),-1,327424,"rotation + translation",G__setup_memvarTGeoCombiTrans,G__setup_memfuncTGeoCombiTrans);
   G__tagtable_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoGenTrans),sizeof(TGeoGenTrans),-1,324864,"rotation + translation + scale",G__setup_memvarTGeoGenTrans,G__setup_memfuncTGeoGenTrans);
   G__tagtable_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoIdentity),sizeof(TGeoIdentity),-1,324864,"identity transformation class",G__setup_memvarTGeoIdentity,G__setup_memfuncTGeoIdentity);
   G__get_linked_tagnum(&G__G__Geom1LN_TAttLine);
   G__get_linked_tagnum(&G__G__Geom1LN_TAtt3D);
   G__tagtable_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoBBox),sizeof(TGeoBBox),-1,324864,"box primitive",G__setup_memvarTGeoBBox,G__setup_memfuncTGeoBBox);
   G__tagtable_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoVolume),sizeof(TGeoVolume),-1,128256,"geometry volume descriptor",G__setup_memvarTGeoVolume,G__setup_memfuncTGeoVolume);
   G__get_linked_tagnum(&G__G__Geom1LN_TBuffer3D);
   G__get_linked_tagnum(&G__G__Geom1LN_TGeoShapecLcLEShapeType);
   G__get_linked_tagnum(&G__G__Geom1LN_TH2F);
   G__tagtable_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoNode),sizeof(TGeoNode),-1,324865,"base class for all geometry nodes",G__setup_memvarTGeoNode,G__setup_memfuncTGeoNode);
   G__tagtable_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoVoxelFinder),sizeof(TGeoVoxelFinder),-1,324864,"voxel finder class",G__setup_memvarTGeoVoxelFinder,G__setup_memfuncTGeoVoxelFinder);
   G__get_linked_tagnum(&G__G__Geom1LN_TGeoPatternFinder);
   G__tagtable_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoManager),sizeof(TGeoManager),-1,128256,"geometry manager",G__setup_memvarTGeoManager,G__setup_memfuncTGeoManager);
   G__get_linked_tagnum(&G__G__Geom1LN_TGeoVolumecLcLEGeoVolumeTypes);
   G__tagtable_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoVolumeMulti),sizeof(TGeoVolumeMulti),-1,324864,"class to handle multiple volumes in one step",G__setup_memvarTGeoVolumeMulti,G__setup_memfuncTGeoVolumeMulti);
   G__tagtable_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoVolumeAssembly),sizeof(TGeoVolumeAssembly),-1,324864,"an assembly of volumes",G__setup_memvarTGeoVolumeAssembly,G__setup_memfuncTGeoVolumeAssembly);
   G__get_linked_tagnum(&G__G__Geom1LN_TGeoVoxelFindercLcLEVoxelsType);
   G__tagtable_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoCylVoxels),sizeof(TGeoCylVoxels),-1,324864,"cylindrical voxel class",G__setup_memvarTGeoCylVoxels,G__setup_memfuncTGeoCylVoxels);
   G__tagtable_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoFullVoxels),sizeof(TGeoFullVoxels),-1,324864,"full voxels class",G__setup_memvarTGeoFullVoxels,G__setup_memfuncTGeoFullVoxels);
   G__get_linked_tagnum(&G__G__Geom1LN_TGeoNodecLcLdA);
   G__tagtable_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoNodeMatrix),sizeof(TGeoNodeMatrix),-1,324864,"a geometry node in the general case",G__setup_memvarTGeoNodeMatrix,G__setup_memfuncTGeoNodeMatrix);
   G__tagtable_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoNodeOffset),sizeof(TGeoNodeOffset),-1,324864,"a geometry node with just an offset",G__setup_memvarTGeoNodeOffset,G__setup_memfuncTGeoNodeOffset);
   G__tagtable_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoPara),sizeof(TGeoPara),-1,324864,"box primitive",G__setup_memvarTGeoPara,G__setup_memfuncTGeoPara);
   G__tagtable_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoTube),sizeof(TGeoTube),-1,324864,"cylindrical tube class",G__setup_memvarTGeoTube,G__setup_memfuncTGeoTube);
   G__tagtable_setup(G__get_linked_tagnum(&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(&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(&G__G__Geom1LN_TGeoTorus),sizeof(TGeoTorus),-1,324864,"torus class",G__setup_memvarTGeoTorus,G__setup_memfuncTGeoTorus);
   G__tagtable_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoSphere),sizeof(TGeoSphere),-1,324864,"sphere class",G__setup_memvarTGeoSphere,G__setup_memfuncTGeoSphere);
   G__tagtable_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoEltu),sizeof(TGeoEltu),-1,324864,"elliptical tube class",G__setup_memvarTGeoEltu,G__setup_memfuncTGeoEltu);
   G__tagtable_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoHype),sizeof(TGeoHype),-1,324864,"hyperboloid class",G__setup_memvarTGeoHype,G__setup_memfuncTGeoHype);
   G__tagtable_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoCone),sizeof(TGeoCone),-1,324864,"conical tube class",G__setup_memvarTGeoCone,G__setup_memfuncTGeoCone);
   G__tagtable_setup(G__get_linked_tagnum(&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(&G__G__Geom1LN_TGeoPcon),sizeof(TGeoPcon),-1,324864,"polycone class ",G__setup_memvarTGeoPcon,G__setup_memfuncTGeoPcon);
   G__tagtable_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoPgon),sizeof(TGeoPgon),-1,324864,"polygone class ",G__setup_memvarTGeoPgon,G__setup_memfuncTGeoPgon);
   G__tagtable_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoArb8),sizeof(TGeoArb8),-1,324864,"arbitrary trapezoid with 8 vertices",G__setup_memvarTGeoArb8,G__setup_memfuncTGeoArb8);
   G__get_linked_tagnum(&G__G__Geom1LN_TGeoArb8cLcLEGeoArb8Type);
   G__tagtable_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoTrap),sizeof(TGeoTrap),-1,324864,"G3 TRAP shape",G__setup_memvarTGeoTrap,G__setup_memfuncTGeoTrap);
   G__tagtable_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoGtra),sizeof(TGeoGtra),-1,324864,"G3 GTRA shape",G__setup_memvarTGeoGtra,G__setup_memfuncTGeoGtra);
   G__tagtable_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoTrd1),sizeof(TGeoTrd1),-1,324864,"TRD1 shape class",G__setup_memvarTGeoTrd1,G__setup_memfuncTGeoTrd1);
   G__tagtable_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoTrd2),sizeof(TGeoTrd2),-1,324864,"TRD2 shape class",G__setup_memvarTGeoTrd2,G__setup_memfuncTGeoTrd2);
   G__get_linked_tagnum(&G__G__Geom1LN_vectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgR);
   G__get_linked_tagnum(&G__G__Geom1LN_reverse_iteratorlEvectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgRcLcLiteratorgR);
   G__get_linked_tagnum(&G__G__Geom1LN_vectorlETStringcOallocatorlETStringgRsPgR);
   G__get_linked_tagnum(&G__G__Geom1LN_reverse_iteratorlEvectorlETStringcOallocatorlETStringgRsPgRcLcLiteratorgR);
   G__get_linked_tagnum(&G__G__Geom1LN_TGeoNodeCache);
   G__tagtable_setup(G__get_linked_tagnum(&G__G__Geom1LN_TVirtualGeoTrack),sizeof(TVirtualGeoTrack),-1,324873,"virtual geometry tracks",G__setup_memvarTVirtualGeoTrack,G__setup_memfuncTVirtualGeoTrack);
   G__tagtable_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoPhysicalNode),sizeof(TGeoPhysicalNode),-1,324864,"base class for physical nodes",G__setup_memvarTGeoPhysicalNode,G__setup_memfuncTGeoPhysicalNode);
   G__tagtable_setup(G__get_linked_tagnum(&G__G__Geom1LN_TVirtualGeoPainter),sizeof(TVirtualGeoPainter),-1,324664,"Abstract interface for geometry painters",G__setup_memvarTVirtualGeoPainter,G__setup_memfuncTVirtualGeoPainter);
   G__tagtable_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoCompositeShape),sizeof(TGeoCompositeShape),-1,324864,"boolean composite shape",G__setup_memvarTGeoCompositeShape,G__setup_memfuncTGeoCompositeShape);
   G__get_linked_tagnum(&G__G__Geom1LN_TVirtualGeoPaintercLcLEGeoVisLevel);
   G__get_linked_tagnum(&G__G__Geom1LN_TVirtualGeoPaintercLcLEGeoVisOption);
   G__get_linked_tagnum(&G__G__Geom1LN_TVirtualGeoPaintercLcLEGeoBombOption);
   G__get_linked_tagnum(&G__G__Geom1LN_TAttMarker);
   G__tagtable_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoPolygon),sizeof(TGeoPolygon),-1,324864,"class for handling arbitrary polygons",G__setup_memvarTGeoPolygon,G__setup_memfuncTGeoPolygon);
   G__get_linked_tagnum(&G__G__Geom1LN_TGeoPolygoncLcLdA);
   G__tagtable_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoXtru),sizeof(TGeoXtru),-1,324864,"extruded polygon class ",G__setup_memvarTGeoXtru,G__setup_memfuncTGeoXtru);
   G__get_linked_tagnum(&G__G__Geom1LN_TGeoPhysicalNodecLcLdA);
   G__tagtable_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoHelix),sizeof(TGeoHelix),-1,324864,"helix class",G__setup_memvarTGeoHelix,G__setup_memfuncTGeoHelix);
   G__get_linked_tagnum(&G__G__Geom1LN_TGeoHelixcLcLEGeoHelixTypes);
   G__tagtable_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoParaboloid),sizeof(TGeoParaboloid),-1,324864,"paraboloid class",G__setup_memvarTGeoParaboloid,G__setup_memfuncTGeoParaboloid);
   G__tagtable_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoHalfSpace),sizeof(TGeoHalfSpace),-1,324864,"half-space class",G__setup_memvarTGeoHalfSpace,G__setup_memfuncTGeoHalfSpace);
}
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;