//
// File generated by rootcint at Mon Sep 30 17:02:03 2013

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

#define R__DICTIONARY_FILENAME dIhomedIformatodIscratchdIdeveldIVirtualMCdISIM_VMCdIPamVMCdItmpdItgt_linuxdIPamVMC_fcdIPamVMC_fcCint
#include "RConfig.h" //rootcint 4834
#if !defined(R__ACCESS_IN_SYMBOL)
//Break the privacy of classes -- Disabled for the moment
#define private public
#define protected public
#endif

// Since CINT ignores the std namespace, we need to do so in this file.
namespace std {} using namespace std;
#include "PamVMC_fcCint.h"

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

#ifndef G__ROOT
#define G__ROOT
#endif

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

// START OF SHADOWS

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

namespace ROOT {
   void PamRootManager_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_PamRootManager(void *p = 0);
   static void *newArray_PamRootManager(Long_t size, void *p);
   static void delete_PamRootManager(void *p);
   static void deleteArray_PamRootManager(void *p);
   static void destruct_PamRootManager(void *p);

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

namespace ROOT {
   void pHitData_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_pHitData(void *p = 0);
   static void *newArray_pHitData(Long_t size, void *p);
   static void delete_pHitData(void *p);
   static void deleteArray_pHitData(void *p);
   static void destruct_pHitData(void *p);

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

namespace ROOT {
   void PamVMCDetectorHit_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_PamVMCDetectorHit(void *p = 0);
   static void *newArray_PamVMCDetectorHit(Long_t size, void *p);
   static void delete_PamVMCDetectorHit(void *p);
   static void deleteArray_PamVMCDetectorHit(void *p);
   static void destruct_PamVMCDetectorHit(void *p);

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

namespace ROOT {
   void PamVMCOptMgr_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_PamVMCOptMgr(void *p);
   static void deleteArray_PamVMCOptMgr(void *p);
   static void destruct_PamVMCOptMgr(void *p);

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

namespace ROOT {
   void PamVMCDigitizer_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_PamVMCDigitizer(void *p);
   static void deleteArray_PamVMCDigitizer(void *p);
   static void destruct_PamVMCDigitizer(void *p);

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

namespace ROOT {
   void GPSSPEData_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_GPSSPEData(void *p = 0);
   static void *newArray_GPSSPEData(Long_t size, void *p);
   static void delete_GPSSPEData(void *p);
   static void deleteArray_GPSSPEData(void *p);
   static void destruct_GPSSPEData(void *p);

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

namespace ROOT {
   void pGPSSPEHits_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_pGPSSPEHits(void *p = 0);
   static void *newArray_pGPSSPEHits(Long_t size, void *p);
   static void delete_pGPSSPEHits(void *p);
   static void deleteArray_pGPSSPEHits(void *p);
   static void destruct_pGPSSPEHits(void *p);

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

namespace ROOT {
   void PamVMCTrkDig_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_PamVMCTrkDig(void *p = 0);
   static void *newArray_PamVMCTrkDig(Long_t size, void *p);
   static void delete_PamVMCTrkDig(void *p);
   static void deleteArray_PamVMCTrkDig(void *p);
   static void destruct_PamVMCTrkDig(void *p);

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

namespace ROOT {
   void PamVMCTofDig_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_PamVMCTofDig(void *p = 0);
   static void *newArray_PamVMCTofDig(Long_t size, void *p);
   static void delete_PamVMCTofDig(void *p);
   static void deleteArray_PamVMCTofDig(void *p);
   static void destruct_PamVMCTofDig(void *p);

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

namespace ROOT {
   void PamVMCAcDig_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_PamVMCAcDig(void *p = 0);
   static void *newArray_PamVMCAcDig(Long_t size, void *p);
   static void delete_PamVMCAcDig(void *p);
   static void deleteArray_PamVMCAcDig(void *p);
   static void destruct_PamVMCAcDig(void *p);

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

namespace ROOT {
   void PamVMCCaloDig_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_PamVMCCaloDig(void *p = 0);
   static void *newArray_PamVMCCaloDig(Long_t size, void *p);
   static void delete_PamVMCCaloDig(void *p);
   static void deleteArray_PamVMCCaloDig(void *p);
   static void destruct_PamVMCCaloDig(void *p);

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

namespace ROOT {
   void PamVMCS4Dig_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_PamVMCS4Dig(void *p = 0);
   static void *newArray_PamVMCS4Dig(Long_t size, void *p);
   static void delete_PamVMCS4Dig(void *p);
   static void deleteArray_PamVMCS4Dig(void *p);
   static void destruct_PamVMCS4Dig(void *p);

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

namespace ROOT {
   void PamVMCNDDig_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_PamVMCNDDig(void *p = 0);
   static void *newArray_PamVMCNDDig(Long_t size, void *p);
   static void delete_PamVMCNDDig(void *p);
   static void deleteArray_PamVMCNDDig(void *p);
   static void destruct_PamVMCNDDig(void *p);

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

namespace ROOT {
   void PamVMCParticle_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_PamVMCParticle(void *p = 0);
   static void *newArray_PamVMCParticle(Long_t size, void *p);
   static void delete_PamVMCParticle(void *p);
   static void deleteArray_PamVMCParticle(void *p);
   static void destruct_PamVMCParticle(void *p);

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

namespace ROOT {
   void PamVMCStack_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_PamVMCStack(void *p = 0);
   static void *newArray_PamVMCStack(Long_t size, void *p);
   static void delete_PamVMCStack(void *p);
   static void deleteArray_PamVMCStack(void *p);
   static void destruct_PamVMCStack(void *p);

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

namespace ROOT {
   void PamVMCDetectorSD_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_PamVMCDetectorSD(void *p = 0);
   static void *newArray_PamVMCDetectorSD(Long_t size, void *p);
   static void delete_PamVMCDetectorSD(void *p);
   static void deleteArray_PamVMCDetectorSD(void *p);
   static void destruct_PamVMCDetectorSD(void *p);

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

namespace ROOT {
   void PamVMCPrimary_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_PamVMCPrimary(void *p = 0);
   static void *newArray_PamVMCPrimary(Long_t size, void *p);
   static void delete_PamVMCPrimary(void *p);
   static void deleteArray_PamVMCPrimary(void *p);
   static void destruct_PamVMCPrimary(void *p);

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

namespace ROOT {
   void PamVMCPrimaryGenerator_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_PamVMCPrimaryGenerator(void *p = 0);
   static void *newArray_PamVMCPrimaryGenerator(Long_t size, void *p);
   static void delete_PamVMCPrimaryGenerator(void *p);
   static void deleteArray_PamVMCPrimaryGenerator(void *p);
   static void destruct_PamVMCPrimaryGenerator(void *p);

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

namespace ROOT {
   void pCutControl_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_pCutControl(void *p = 0);
   static void *newArray_pCutControl(Long_t size, void *p);
   static void delete_pCutControl(void *p);
   static void deleteArray_pCutControl(void *p);
   static void destruct_pCutControl(void *p);

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

namespace ROOT {
   void PamVMCDetGeom_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_PamVMCDetGeom(void *p = 0);
   static void *newArray_PamVMCDetGeom(Long_t size, void *p);
   static void delete_PamVMCDetGeom(void *p);
   static void deleteArray_PamVMCDetGeom(void *p);
   static void destruct_PamVMCDetGeom(void *p);

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

namespace ROOT {
   void PamVMCDetector_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_PamVMCDetector(void *p);
   static void deleteArray_PamVMCDetector(void *p);
   static void destruct_PamVMCDetector(void *p);

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

namespace ROOT {
   void PamVMCCaloSD_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_PamVMCCaloSD(void *p = 0);
   static void *newArray_PamVMCCaloSD(Long_t size, void *p);
   static void delete_PamVMCCaloSD(void *p);
   static void deleteArray_PamVMCCaloSD(void *p);
   static void destruct_PamVMCCaloSD(void *p);

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

namespace ROOT {
   void PamVMCDetCalo_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_PamVMCDetCalo(void *p = 0);
   static void *newArray_PamVMCDetCalo(Long_t size, void *p);
   static void delete_PamVMCDetCalo(void *p);
   static void deleteArray_PamVMCDetCalo(void *p);
   static void destruct_PamVMCDetCalo(void *p);

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

namespace ROOT {
   void pTrkHitData_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_pTrkHitData(void *p = 0);
   static void *newArray_pTrkHitData(Long_t size, void *p);
   static void delete_pTrkHitData(void *p);
   static void deleteArray_pTrkHitData(void *p);
   static void destruct_pTrkHitData(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::pTrkHitData*)
   {
      ::pTrkHitData *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::pTrkHitData >(0);
      static ::ROOT::TGenericClassInfo 
         instance("pTrkHitData", ::pTrkHitData::Class_Version(), "trk/include/PamVMCTrkHit.h", 17,
                  typeid(::pTrkHitData), DefineBehavior(ptr, ptr),
                  &::pTrkHitData::Dictionary, isa_proxy, 4,
                  sizeof(::pTrkHitData) );
      instance.SetNew(&new_pTrkHitData);
      instance.SetNewArray(&newArray_pTrkHitData);
      instance.SetDelete(&delete_pTrkHitData);
      instance.SetDeleteArray(&deleteArray_pTrkHitData);
      instance.SetDestructor(&destruct_pTrkHitData);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::pTrkHitData*)
   {
      return GenerateInitInstanceLocal((::pTrkHitData*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::pTrkHitData*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void PamVMCTrkHit_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_PamVMCTrkHit(void *p = 0);
   static void *newArray_PamVMCTrkHit(Long_t size, void *p);
   static void delete_PamVMCTrkHit(void *p);
   static void deleteArray_PamVMCTrkHit(void *p);
   static void destruct_PamVMCTrkHit(void *p);

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

namespace ROOT {
   void PamVMCTrkSD_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_PamVMCTrkSD(void *p = 0);
   static void *newArray_PamVMCTrkSD(Long_t size, void *p);
   static void delete_PamVMCTrkSD(void *p);
   static void deleteArray_PamVMCTrkSD(void *p);
   static void destruct_PamVMCTrkSD(void *p);

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

namespace ROOT {
   void PamVMCDetTrk_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_PamVMCDetTrk(void *p = 0);
   static void *newArray_PamVMCDetTrk(Long_t size, void *p);
   static void delete_PamVMCDetTrk(void *p);
   static void deleteArray_PamVMCDetTrk(void *p);
   static void destruct_PamVMCDetTrk(void *p);

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

namespace ROOT {
   void PamVMCTofSD_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_PamVMCTofSD(void *p);
   static void deleteArray_PamVMCTofSD(void *p);
   static void destruct_PamVMCTofSD(void *p);

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

namespace ROOT {
   void PamVMCDetTofS1_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_PamVMCDetTofS1(void *p = 0);
   static void *newArray_PamVMCDetTofS1(Long_t size, void *p);
   static void delete_PamVMCDetTofS1(void *p);
   static void deleteArray_PamVMCDetTofS1(void *p);
   static void destruct_PamVMCDetTofS1(void *p);

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

namespace ROOT {
   void PamVMCDetTofS2_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_PamVMCDetTofS2(void *p = 0);
   static void *newArray_PamVMCDetTofS2(Long_t size, void *p);
   static void delete_PamVMCDetTofS2(void *p);
   static void deleteArray_PamVMCDetTofS2(void *p);
   static void destruct_PamVMCDetTofS2(void *p);

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

namespace ROOT {
   void PamVMCDetTofS3_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_PamVMCDetTofS3(void *p = 0);
   static void *newArray_PamVMCDetTofS3(Long_t size, void *p);
   static void delete_PamVMCDetTofS3(void *p);
   static void deleteArray_PamVMCDetTofS3(void *p);
   static void destruct_PamVMCDetTofS3(void *p);

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

namespace ROOT {
   void PamVMCDetTof_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_PamVMCDetTof(void *p = 0);
   static void *newArray_PamVMCDetTof(Long_t size, void *p);
   static void delete_PamVMCDetTof(void *p);
   static void deleteArray_PamVMCDetTof(void *p);
   static void destruct_PamVMCDetTof(void *p);

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

namespace ROOT {
   void PamVMCCardSD_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_PamVMCCardSD(void *p);
   static void deleteArray_PamVMCCardSD(void *p);
   static void destruct_PamVMCCardSD(void *p);

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

namespace ROOT {
   void PamVMCDetCard_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_PamVMCDetCard(void *p = 0);
   static void *newArray_PamVMCDetCard(Long_t size, void *p);
   static void delete_PamVMCDetCard(void *p);
   static void deleteArray_PamVMCDetCard(void *p);
   static void destruct_PamVMCDetCard(void *p);

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

namespace ROOT {
   void PamVMCCasSD_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_PamVMCCasSD(void *p = 0);
   static void *newArray_PamVMCCasSD(Long_t size, void *p);
   static void delete_PamVMCCasSD(void *p);
   static void deleteArray_PamVMCCasSD(void *p);
   static void destruct_PamVMCCasSD(void *p);

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

namespace ROOT {
   void PamVMCDetCas_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_PamVMCDetCas(void *p = 0);
   static void *newArray_PamVMCDetCas(Long_t size, void *p);
   static void delete_PamVMCDetCas(void *p);
   static void deleteArray_PamVMCDetCas(void *p);
   static void destruct_PamVMCDetCas(void *p);

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

namespace ROOT {
   void PamVMCCatSD_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_PamVMCCatSD(void *p = 0);
   static void *newArray_PamVMCCatSD(Long_t size, void *p);
   static void delete_PamVMCCatSD(void *p);
   static void deleteArray_PamVMCCatSD(void *p);
   static void destruct_PamVMCCatSD(void *p);

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

namespace ROOT {
   void PamVMCDetCat_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_PamVMCDetCat(void *p = 0);
   static void *newArray_PamVMCDetCat(Long_t size, void *p);
   static void delete_PamVMCDetCat(void *p);
   static void deleteArray_PamVMCDetCat(void *p);
   static void destruct_PamVMCDetCat(void *p);

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

namespace ROOT {
   void PamVMCDetAc_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_PamVMCDetAc(void *p = 0);
   static void *newArray_PamVMCDetAc(Long_t size, void *p);
   static void delete_PamVMCDetAc(void *p);
   static void deleteArray_PamVMCDetAc(void *p);
   static void destruct_PamVMCDetAc(void *p);

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

namespace ROOT {
   void PamVMCS4SD_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_PamVMCS4SD(void *p = 0);
   static void *newArray_PamVMCS4SD(Long_t size, void *p);
   static void delete_PamVMCS4SD(void *p);
   static void deleteArray_PamVMCS4SD(void *p);
   static void destruct_PamVMCS4SD(void *p);

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

namespace ROOT {
   void PamVMCDetS4_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_PamVMCDetS4(void *p = 0);
   static void *newArray_PamVMCDetS4(Long_t size, void *p);
   static void delete_PamVMCDetS4(void *p);
   static void deleteArray_PamVMCDetS4(void *p);
   static void destruct_PamVMCDetS4(void *p);

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

namespace ROOT {
   void PamVMCNDSD_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_PamVMCNDSD(void *p = 0);
   static void *newArray_PamVMCNDSD(Long_t size, void *p);
   static void delete_PamVMCNDSD(void *p);
   static void deleteArray_PamVMCNDSD(void *p);
   static void destruct_PamVMCNDSD(void *p);

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

namespace ROOT {
   void PamVMCDetND_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_PamVMCDetND(void *p = 0);
   static void *newArray_PamVMCDetND(Long_t size, void *p);
   static void delete_PamVMCDetND(void *p);
   static void deleteArray_PamVMCDetND(void *p);
   static void destruct_PamVMCDetND(void *p);

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

namespace ROOT {
   void PamVMCDetPamela_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_PamVMCDetPamela(void *p = 0);
   static void *newArray_PamVMCDetPamela(Long_t size, void *p);
   static void delete_PamVMCDetPamela(void *p);
   static void deleteArray_PamVMCDetPamela(void *p);
   static void destruct_PamVMCDetPamela(void *p);

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

namespace ROOT {
   void PamVMCApplication_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_PamVMCApplication(void *p);
   static void deleteArray_PamVMCApplication(void *p);
   static void destruct_PamVMCApplication(void *p);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

//______________________________________________________________________________
void PamVMCApplication::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class PamVMCApplication.
      TClass *R__cl = ::PamVMCApplication::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fEventNo", &fEventNo);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fVerbose", &fVerbose);
      R__insp.InspectMember(fVerbose, "fVerbose.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fStack", &fStack);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fdetector", &fdetector);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fPrimaryGenerator", &fPrimaryGenerator);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fRootManager", &fRootManager);
      R__insp.InspectMember(fRootManager, "fRootManager.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*frandom", &frandom);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fdstatus", &fdstatus);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "ftrig", &ftrig);
      TVirtualMCApplication::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrapper around operator delete
   static void delete_PamVMCApplication(void *p) {
      delete ((::PamVMCApplication*)p);
   }
   static void deleteArray_PamVMCApplication(void *p) {
      delete [] ((::PamVMCApplication*)p);
   }
   static void destruct_PamVMCApplication(void *p) {
      typedef ::PamVMCApplication current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::PamVMCApplication

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

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

//______________________________________________________________________________
void PamVMCStack::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class PamVMCStack.
      TClass *R__cl = ::PamVMCStack::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fStack", (void*)&fStack);
      R__insp.InspectMember("stack<PamVMCParticle*>", (void*)&fStack, "fStack.", true);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fParticles", &fParticles);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fCurrentTrack", &fCurrentTrack);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNPrimary", &fNPrimary);
      TVirtualMCStack::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_PamVMCStack(void *p) {
      return  p ? new(p) ::PamVMCStack : new ::PamVMCStack;
   }
   static void *newArray_PamVMCStack(Long_t nElements, void *p) {
      return p ? new(p) ::PamVMCStack[nElements] : new ::PamVMCStack[nElements];
   }
   // Wrapper around operator delete
   static void delete_PamVMCStack(void *p) {
      delete ((::PamVMCStack*)p);
   }
   static void deleteArray_PamVMCStack(void *p) {
      delete [] ((::PamVMCStack*)p);
   }
   static void destruct_PamVMCStack(void *p) {
      typedef ::PamVMCStack current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::PamVMCStack

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

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

//______________________________________________________________________________
void PamVMCPrimaryGenerator::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class PamVMCPrimaryGenerator.
      TClass *R__cl = ::PamVMCPrimaryGenerator::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fStack", &fStack);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fevno", &fevno);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fngood", &fngood);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fprim", &fprim);
      R__insp.InspectMember(fprim, "fprim.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fmass", &fmass);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fcharge", &fcharge);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fxprev", &fxprev);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fyprev", &fyprev);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fzprev", &fzprev);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fprimColl", &fprimColl);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*frandom", &frandom);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*ftheta", &ftheta);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*f2PiAux", &f2PiAux);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fpgf", &fpgf);
      TObject::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_PamVMCPrimaryGenerator(void *p) {
      return  p ? new(p) ::PamVMCPrimaryGenerator : new ::PamVMCPrimaryGenerator;
   }
   static void *newArray_PamVMCPrimaryGenerator(Long_t nElements, void *p) {
      return p ? new(p) ::PamVMCPrimaryGenerator[nElements] : new ::PamVMCPrimaryGenerator[nElements];
   }
   // Wrapper around operator delete
   static void delete_PamVMCPrimaryGenerator(void *p) {
      delete ((::PamVMCPrimaryGenerator*)p);
   }
   static void deleteArray_PamVMCPrimaryGenerator(void *p) {
      delete [] ((::PamVMCPrimaryGenerator*)p);
   }
   static void destruct_PamVMCPrimaryGenerator(void *p) {
      typedef ::PamVMCPrimaryGenerator current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::PamVMCPrimaryGenerator

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

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

//______________________________________________________________________________
void PamVMCPrimary::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class PamVMCPrimary.
      TClass *R__cl = ::PamVMCPrimary::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fID", &fID);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fPDG", &fPDG);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fX0", &fX0);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fY0", &fY0);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fZ0", &fZ0);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTHETA", &fTHETA);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fPHI", &fPHI);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fP0", &fP0);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fGOOD", &fGOOD);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fXTOL", &fXTOL);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fYTOL", &fYTOL);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fCR_X[14]", fCR_X);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fCR_Y[14]", fCR_Y);
      TObject::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_PamVMCPrimary(void *p) {
      return  p ? new(p) ::PamVMCPrimary : new ::PamVMCPrimary;
   }
   static void *newArray_PamVMCPrimary(Long_t nElements, void *p) {
      return p ? new(p) ::PamVMCPrimary[nElements] : new ::PamVMCPrimary[nElements];
   }
   // Wrapper around operator delete
   static void delete_PamVMCPrimary(void *p) {
      delete ((::PamVMCPrimary*)p);
   }
   static void deleteArray_PamVMCPrimary(void *p) {
      delete [] ((::PamVMCPrimary*)p);
   }
   static void destruct_PamVMCPrimary(void *p) {
      typedef ::PamVMCPrimary current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::PamVMCPrimary

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

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

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_PamRootManager(void *p) {
      return  p ? new(p) ::PamRootManager : new ::PamRootManager;
   }
   static void *newArray_PamRootManager(Long_t nElements, void *p) {
      return p ? new(p) ::PamRootManager[nElements] : new ::PamRootManager[nElements];
   }
   // Wrapper around operator delete
   static void delete_PamRootManager(void *p) {
      delete ((::PamRootManager*)p);
   }
   static void deleteArray_PamRootManager(void *p) {
      delete [] ((::PamRootManager*)p);
   }
   static void destruct_PamRootManager(void *p) {
      typedef ::PamRootManager current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::PamRootManager

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

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

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_PamVMCDetectorHit(void *p) {
      return  p ? new(p) ::PamVMCDetectorHit : new ::PamVMCDetectorHit;
   }
   static void *newArray_PamVMCDetectorHit(Long_t nElements, void *p) {
      return p ? new(p) ::PamVMCDetectorHit[nElements] : new ::PamVMCDetectorHit[nElements];
   }
   // Wrapper around operator delete
   static void delete_PamVMCDetectorHit(void *p) {
      delete ((::PamVMCDetectorHit*)p);
   }
   static void deleteArray_PamVMCDetectorHit(void *p) {
      delete [] ((::PamVMCDetectorHit*)p);
   }
   static void destruct_PamVMCDetectorHit(void *p) {
      typedef ::PamVMCDetectorHit current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::PamVMCDetectorHit

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

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

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_PamVMCTrkHit(void *p) {
      return  p ? new(p) ::PamVMCTrkHit : new ::PamVMCTrkHit;
   }
   static void *newArray_PamVMCTrkHit(Long_t nElements, void *p) {
      return p ? new(p) ::PamVMCTrkHit[nElements] : new ::PamVMCTrkHit[nElements];
   }
   // Wrapper around operator delete
   static void delete_PamVMCTrkHit(void *p) {
      delete ((::PamVMCTrkHit*)p);
   }
   static void deleteArray_PamVMCTrkHit(void *p) {
      delete [] ((::PamVMCTrkHit*)p);
   }
   static void destruct_PamVMCTrkHit(void *p) {
      typedef ::PamVMCTrkHit current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::PamVMCTrkHit

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

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

//______________________________________________________________________________
void pCutControl::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class pCutControl.
      TClass *R__cl = ::pCutControl::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fid", &fid);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fid_m", &fid_m);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fCUTGAM", &fCUTGAM);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fBCUTE", &fBCUTE);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fCUTELE", &fCUTELE);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fDCUTE", &fDCUTE);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fCUTNEU", &fCUTNEU);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fCUTHAD", &fCUTHAD);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fCUTMUO", &fCUTMUO);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fDCUTM", &fDCUTM);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fBCUTM", &fBCUTM);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fPPCUTM", &fPPCUTM);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fPAIR", &fPAIR);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fCOMP", &fCOMP);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fPHOT", &fPHOT);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fPFIS", &fPFIS);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fDRAY", &fDRAY);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fANNI", &fANNI);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fBREM", &fBREM);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fHADR", &fHADR);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMUNU", &fMUNU);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fDCAY", &fDCAY);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fLOSS", &fLOSS);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMULS", &fMULS);
      TObject::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_pCutControl(void *p) {
      return  p ? new(p) ::pCutControl : new ::pCutControl;
   }
   static void *newArray_pCutControl(Long_t nElements, void *p) {
      return p ? new(p) ::pCutControl[nElements] : new ::pCutControl[nElements];
   }
   // Wrapper around operator delete
   static void delete_pCutControl(void *p) {
      delete ((::pCutControl*)p);
   }
   static void deleteArray_pCutControl(void *p) {
      delete [] ((::pCutControl*)p);
   }
   static void destruct_pCutControl(void *p) {
      typedef ::pCutControl current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::pCutControl

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

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

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

namespace ROOT {
   // Wrapper around operator delete
   static void delete_PamVMCDetector(void *p) {
      delete ((::PamVMCDetector*)p);
   }
   static void deleteArray_PamVMCDetector(void *p) {
      delete [] ((::PamVMCDetector*)p);
   }
   static void destruct_PamVMCDetector(void *p) {
      typedef ::PamVMCDetector current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::PamVMCDetector

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

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

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_PamVMCDetPamela(void *p) {
      return  p ? new(p) ::PamVMCDetPamela : new ::PamVMCDetPamela;
   }
   static void *newArray_PamVMCDetPamela(Long_t nElements, void *p) {
      return p ? new(p) ::PamVMCDetPamela[nElements] : new ::PamVMCDetPamela[nElements];
   }
   // Wrapper around operator delete
   static void delete_PamVMCDetPamela(void *p) {
      delete ((::PamVMCDetPamela*)p);
   }
   static void deleteArray_PamVMCDetPamela(void *p) {
      delete [] ((::PamVMCDetPamela*)p);
   }
   static void destruct_PamVMCDetPamela(void *p) {
      typedef ::PamVMCDetPamela current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::PamVMCDetPamela

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

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

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_PamVMCDetCalo(void *p) {
      return  p ? new(p) ::PamVMCDetCalo : new ::PamVMCDetCalo;
   }
   static void *newArray_PamVMCDetCalo(Long_t nElements, void *p) {
      return p ? new(p) ::PamVMCDetCalo[nElements] : new ::PamVMCDetCalo[nElements];
   }
   // Wrapper around operator delete
   static void delete_PamVMCDetCalo(void *p) {
      delete ((::PamVMCDetCalo*)p);
   }
   static void deleteArray_PamVMCDetCalo(void *p) {
      delete [] ((::PamVMCDetCalo*)p);
   }
   static void destruct_PamVMCDetCalo(void *p) {
      typedef ::PamVMCDetCalo current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::PamVMCDetCalo

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

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

//______________________________________________________________________________
void PamVMCDetTrk::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class PamVMCDetTrk.
      TClass *R__cl = ::PamVMCDetTrk::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "dxflo[36]", dxflo);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "dyflo[36]", dyflo);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fctmap", (void*)&fctmap);
      R__insp.InspectMember("CombTransMap", (void*)&fctmap, "fctmap.", false);
      PamVMCDetector::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_PamVMCDetTrk(void *p) {
      return  p ? new(p) ::PamVMCDetTrk : new ::PamVMCDetTrk;
   }
   static void *newArray_PamVMCDetTrk(Long_t nElements, void *p) {
      return p ? new(p) ::PamVMCDetTrk[nElements] : new ::PamVMCDetTrk[nElements];
   }
   // Wrapper around operator delete
   static void delete_PamVMCDetTrk(void *p) {
      delete ((::PamVMCDetTrk*)p);
   }
   static void deleteArray_PamVMCDetTrk(void *p) {
      delete [] ((::PamVMCDetTrk*)p);
   }
   static void destruct_PamVMCDetTrk(void *p) {
      typedef ::PamVMCDetTrk current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::PamVMCDetTrk

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

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

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_PamVMCDetTof(void *p) {
      return  p ? new(p) ::PamVMCDetTof : new ::PamVMCDetTof;
   }
   static void *newArray_PamVMCDetTof(Long_t nElements, void *p) {
      return p ? new(p) ::PamVMCDetTof[nElements] : new ::PamVMCDetTof[nElements];
   }
   // Wrapper around operator delete
   static void delete_PamVMCDetTof(void *p) {
      delete ((::PamVMCDetTof*)p);
   }
   static void deleteArray_PamVMCDetTof(void *p) {
      delete [] ((::PamVMCDetTof*)p);
   }
   static void destruct_PamVMCDetTof(void *p) {
      typedef ::PamVMCDetTof current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::PamVMCDetTof

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

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

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_PamVMCDetTofS1(void *p) {
      return  p ? new(p) ::PamVMCDetTofS1 : new ::PamVMCDetTofS1;
   }
   static void *newArray_PamVMCDetTofS1(Long_t nElements, void *p) {
      return p ? new(p) ::PamVMCDetTofS1[nElements] : new ::PamVMCDetTofS1[nElements];
   }
   // Wrapper around operator delete
   static void delete_PamVMCDetTofS1(void *p) {
      delete ((::PamVMCDetTofS1*)p);
   }
   static void deleteArray_PamVMCDetTofS1(void *p) {
      delete [] ((::PamVMCDetTofS1*)p);
   }
   static void destruct_PamVMCDetTofS1(void *p) {
      typedef ::PamVMCDetTofS1 current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::PamVMCDetTofS1

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

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

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_PamVMCDetTofS2(void *p) {
      return  p ? new(p) ::PamVMCDetTofS2 : new ::PamVMCDetTofS2;
   }
   static void *newArray_PamVMCDetTofS2(Long_t nElements, void *p) {
      return p ? new(p) ::PamVMCDetTofS2[nElements] : new ::PamVMCDetTofS2[nElements];
   }
   // Wrapper around operator delete
   static void delete_PamVMCDetTofS2(void *p) {
      delete ((::PamVMCDetTofS2*)p);
   }
   static void deleteArray_PamVMCDetTofS2(void *p) {
      delete [] ((::PamVMCDetTofS2*)p);
   }
   static void destruct_PamVMCDetTofS2(void *p) {
      typedef ::PamVMCDetTofS2 current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::PamVMCDetTofS2

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

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

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_PamVMCDetTofS3(void *p) {
      return  p ? new(p) ::PamVMCDetTofS3 : new ::PamVMCDetTofS3;
   }
   static void *newArray_PamVMCDetTofS3(Long_t nElements, void *p) {
      return p ? new(p) ::PamVMCDetTofS3[nElements] : new ::PamVMCDetTofS3[nElements];
   }
   // Wrapper around operator delete
   static void delete_PamVMCDetTofS3(void *p) {
      delete ((::PamVMCDetTofS3*)p);
   }
   static void deleteArray_PamVMCDetTofS3(void *p) {
      delete [] ((::PamVMCDetTofS3*)p);
   }
   static void destruct_PamVMCDetTofS3(void *p) {
      typedef ::PamVMCDetTofS3 current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::PamVMCDetTofS3

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

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

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_PamVMCDetAc(void *p) {
      return  p ? new(p) ::PamVMCDetAc : new ::PamVMCDetAc;
   }
   static void *newArray_PamVMCDetAc(Long_t nElements, void *p) {
      return p ? new(p) ::PamVMCDetAc[nElements] : new ::PamVMCDetAc[nElements];
   }
   // Wrapper around operator delete
   static void delete_PamVMCDetAc(void *p) {
      delete ((::PamVMCDetAc*)p);
   }
   static void deleteArray_PamVMCDetAc(void *p) {
      delete [] ((::PamVMCDetAc*)p);
   }
   static void destruct_PamVMCDetAc(void *p) {
      typedef ::PamVMCDetAc current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::PamVMCDetAc

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

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

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_PamVMCDetCard(void *p) {
      return  p ? new(p) ::PamVMCDetCard : new ::PamVMCDetCard;
   }
   static void *newArray_PamVMCDetCard(Long_t nElements, void *p) {
      return p ? new(p) ::PamVMCDetCard[nElements] : new ::PamVMCDetCard[nElements];
   }
   // Wrapper around operator delete
   static void delete_PamVMCDetCard(void *p) {
      delete ((::PamVMCDetCard*)p);
   }
   static void deleteArray_PamVMCDetCard(void *p) {
      delete [] ((::PamVMCDetCard*)p);
   }
   static void destruct_PamVMCDetCard(void *p) {
      typedef ::PamVMCDetCard current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::PamVMCDetCard

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

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

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_PamVMCDetCas(void *p) {
      return  p ? new(p) ::PamVMCDetCas : new ::PamVMCDetCas;
   }
   static void *newArray_PamVMCDetCas(Long_t nElements, void *p) {
      return p ? new(p) ::PamVMCDetCas[nElements] : new ::PamVMCDetCas[nElements];
   }
   // Wrapper around operator delete
   static void delete_PamVMCDetCas(void *p) {
      delete ((::PamVMCDetCas*)p);
   }
   static void deleteArray_PamVMCDetCas(void *p) {
      delete [] ((::PamVMCDetCas*)p);
   }
   static void destruct_PamVMCDetCas(void *p) {
      typedef ::PamVMCDetCas current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::PamVMCDetCas

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

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

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_PamVMCDetCat(void *p) {
      return  p ? new(p) ::PamVMCDetCat : new ::PamVMCDetCat;
   }
   static void *newArray_PamVMCDetCat(Long_t nElements, void *p) {
      return p ? new(p) ::PamVMCDetCat[nElements] : new ::PamVMCDetCat[nElements];
   }
   // Wrapper around operator delete
   static void delete_PamVMCDetCat(void *p) {
      delete ((::PamVMCDetCat*)p);
   }
   static void deleteArray_PamVMCDetCat(void *p) {
      delete [] ((::PamVMCDetCat*)p);
   }
   static void destruct_PamVMCDetCat(void *p) {
      typedef ::PamVMCDetCat current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::PamVMCDetCat

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

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

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_PamVMCDetS4(void *p) {
      return  p ? new(p) ::PamVMCDetS4 : new ::PamVMCDetS4;
   }
   static void *newArray_PamVMCDetS4(Long_t nElements, void *p) {
      return p ? new(p) ::PamVMCDetS4[nElements] : new ::PamVMCDetS4[nElements];
   }
   // Wrapper around operator delete
   static void delete_PamVMCDetS4(void *p) {
      delete ((::PamVMCDetS4*)p);
   }
   static void deleteArray_PamVMCDetS4(void *p) {
      delete [] ((::PamVMCDetS4*)p);
   }
   static void destruct_PamVMCDetS4(void *p) {
      typedef ::PamVMCDetS4 current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::PamVMCDetS4

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

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

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_PamVMCDetND(void *p) {
      return  p ? new(p) ::PamVMCDetND : new ::PamVMCDetND;
   }
   static void *newArray_PamVMCDetND(Long_t nElements, void *p) {
      return p ? new(p) ::PamVMCDetND[nElements] : new ::PamVMCDetND[nElements];
   }
   // Wrapper around operator delete
   static void delete_PamVMCDetND(void *p) {
      delete ((::PamVMCDetND*)p);
   }
   static void deleteArray_PamVMCDetND(void *p) {
      delete [] ((::PamVMCDetND*)p);
   }
   static void destruct_PamVMCDetND(void *p) {
      typedef ::PamVMCDetND current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::PamVMCDetND

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

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

//______________________________________________________________________________
void PamVMCDetGeom::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class PamVMCDetGeom.
      TClass *R__cl = ::PamVMCDetGeom::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fdname", &fdname);
      R__insp.InspectMember(fdname, "fdname.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fdrot", &fdrot);
      R__insp.InspectMember(fdrot, "fdrot.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fmotherprop", &fmotherprop);
      R__insp.InspectMember(fmotherprop, "fmotherprop.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fmat", &fmat);
      R__insp.InspectMember(fmat, "fmat.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fmix", &fmix);
      R__insp.InspectMember(fmix, "fmix.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fmed", &fmed);
      R__insp.InspectMember(fmed, "fmed.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fvol", &fvol);
      R__insp.InspectMember(fvol, "fvol.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fmother", &fmother);
      TObject::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_PamVMCDetGeom(void *p) {
      return  p ? new(p) ::PamVMCDetGeom : new ::PamVMCDetGeom;
   }
   static void *newArray_PamVMCDetGeom(Long_t nElements, void *p) {
      return p ? new(p) ::PamVMCDetGeom[nElements] : new ::PamVMCDetGeom[nElements];
   }
   // Wrapper around operator delete
   static void delete_PamVMCDetGeom(void *p) {
      delete ((::PamVMCDetGeom*)p);
   }
   static void deleteArray_PamVMCDetGeom(void *p) {
      delete [] ((::PamVMCDetGeom*)p);
   }
   static void destruct_PamVMCDetGeom(void *p) {
      typedef ::PamVMCDetGeom current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::PamVMCDetGeom

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

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

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_PamVMCParticle(void *p) {
      return  p ? new(p) ::PamVMCParticle : new ::PamVMCParticle;
   }
   static void *newArray_PamVMCParticle(Long_t nElements, void *p) {
      return p ? new(p) ::PamVMCParticle[nElements] : new ::PamVMCParticle[nElements];
   }
   // Wrapper around operator delete
   static void delete_PamVMCParticle(void *p) {
      delete ((::PamVMCParticle*)p);
   }
   static void deleteArray_PamVMCParticle(void *p) {
      delete [] ((::PamVMCParticle*)p);
   }
   static void destruct_PamVMCParticle(void *p) {
      typedef ::PamVMCParticle current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::PamVMCParticle

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

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

//______________________________________________________________________________
void PamVMCDetectorSD::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class PamVMCDetectorSD.
      TClass *R__cl = ::PamVMCDetectorSD::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fcname", &fcname);
      R__insp.InspectMember(fcname, "fcname.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fdname", &fdname);
      R__insp.InspectMember(fdname, "fdname.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fnohit", &fnohit);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "ffi", &ffi);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fHitColl", &fHitColl);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fdmap", &fdmap);
      R__insp.InspectMember(fdmap, "fdmap.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fdetID", &fdetID);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fhit", &fhit);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fdig", &fdig);
      TObject::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_PamVMCDetectorSD(void *p) {
      return  p ? new(p) ::PamVMCDetectorSD : new ::PamVMCDetectorSD;
   }
   static void *newArray_PamVMCDetectorSD(Long_t nElements, void *p) {
      return p ? new(p) ::PamVMCDetectorSD[nElements] : new ::PamVMCDetectorSD[nElements];
   }
   // Wrapper around operator delete
   static void delete_PamVMCDetectorSD(void *p) {
      delete ((::PamVMCDetectorSD*)p);
   }
   static void deleteArray_PamVMCDetectorSD(void *p) {
      delete [] ((::PamVMCDetectorSD*)p);
   }
   static void destruct_PamVMCDetectorSD(void *p) {
      typedef ::PamVMCDetectorSD current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::PamVMCDetectorSD

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

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

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_PamVMCCaloSD(void *p) {
      return  p ? new(p) ::PamVMCCaloSD : new ::PamVMCCaloSD;
   }
   static void *newArray_PamVMCCaloSD(Long_t nElements, void *p) {
      return p ? new(p) ::PamVMCCaloSD[nElements] : new ::PamVMCCaloSD[nElements];
   }
   // Wrapper around operator delete
   static void delete_PamVMCCaloSD(void *p) {
      delete ((::PamVMCCaloSD*)p);
   }
   static void deleteArray_PamVMCCaloSD(void *p) {
      delete [] ((::PamVMCCaloSD*)p);
   }
   static void destruct_PamVMCCaloSD(void *p) {
      typedef ::PamVMCCaloSD current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::PamVMCCaloSD

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

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

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

namespace ROOT {
   // Wrapper around operator delete
   static void delete_PamVMCTofSD(void *p) {
      delete ((::PamVMCTofSD*)p);
   }
   static void deleteArray_PamVMCTofSD(void *p) {
      delete [] ((::PamVMCTofSD*)p);
   }
   static void destruct_PamVMCTofSD(void *p) {
      typedef ::PamVMCTofSD current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::PamVMCTofSD

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

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

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_PamVMCTrkSD(void *p) {
      return  p ? new(p) ::PamVMCTrkSD : new ::PamVMCTrkSD;
   }
   static void *newArray_PamVMCTrkSD(Long_t nElements, void *p) {
      return p ? new(p) ::PamVMCTrkSD[nElements] : new ::PamVMCTrkSD[nElements];
   }
   // Wrapper around operator delete
   static void delete_PamVMCTrkSD(void *p) {
      delete ((::PamVMCTrkSD*)p);
   }
   static void deleteArray_PamVMCTrkSD(void *p) {
      delete [] ((::PamVMCTrkSD*)p);
   }
   static void destruct_PamVMCTrkSD(void *p) {
      typedef ::PamVMCTrkSD current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::PamVMCTrkSD

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

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

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

namespace ROOT {
   // Wrapper around operator delete
   static void delete_PamVMCCardSD(void *p) {
      delete ((::PamVMCCardSD*)p);
   }
   static void deleteArray_PamVMCCardSD(void *p) {
      delete [] ((::PamVMCCardSD*)p);
   }
   static void destruct_PamVMCCardSD(void *p) {
      typedef ::PamVMCCardSD current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::PamVMCCardSD

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

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

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_PamVMCCasSD(void *p) {
      return  p ? new(p) ::PamVMCCasSD : new ::PamVMCCasSD;
   }
   static void *newArray_PamVMCCasSD(Long_t nElements, void *p) {
      return p ? new(p) ::PamVMCCasSD[nElements] : new ::PamVMCCasSD[nElements];
   }
   // Wrapper around operator delete
   static void delete_PamVMCCasSD(void *p) {
      delete ((::PamVMCCasSD*)p);
   }
   static void deleteArray_PamVMCCasSD(void *p) {
      delete [] ((::PamVMCCasSD*)p);
   }
   static void destruct_PamVMCCasSD(void *p) {
      typedef ::PamVMCCasSD current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::PamVMCCasSD

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

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

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_PamVMCCatSD(void *p) {
      return  p ? new(p) ::PamVMCCatSD : new ::PamVMCCatSD;
   }
   static void *newArray_PamVMCCatSD(Long_t nElements, void *p) {
      return p ? new(p) ::PamVMCCatSD[nElements] : new ::PamVMCCatSD[nElements];
   }
   // Wrapper around operator delete
   static void delete_PamVMCCatSD(void *p) {
      delete ((::PamVMCCatSD*)p);
   }
   static void deleteArray_PamVMCCatSD(void *p) {
      delete [] ((::PamVMCCatSD*)p);
   }
   static void destruct_PamVMCCatSD(void *p) {
      typedef ::PamVMCCatSD current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::PamVMCCatSD

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

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

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_PamVMCS4SD(void *p) {
      return  p ? new(p) ::PamVMCS4SD : new ::PamVMCS4SD;
   }
   static void *newArray_PamVMCS4SD(Long_t nElements, void *p) {
      return p ? new(p) ::PamVMCS4SD[nElements] : new ::PamVMCS4SD[nElements];
   }
   // Wrapper around operator delete
   static void delete_PamVMCS4SD(void *p) {
      delete ((::PamVMCS4SD*)p);
   }
   static void deleteArray_PamVMCS4SD(void *p) {
      delete [] ((::PamVMCS4SD*)p);
   }
   static void destruct_PamVMCS4SD(void *p) {
      typedef ::PamVMCS4SD current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::PamVMCS4SD

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

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

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_PamVMCNDSD(void *p) {
      return  p ? new(p) ::PamVMCNDSD : new ::PamVMCNDSD;
   }
   static void *newArray_PamVMCNDSD(Long_t nElements, void *p) {
      return p ? new(p) ::PamVMCNDSD[nElements] : new ::PamVMCNDSD[nElements];
   }
   // Wrapper around operator delete
   static void delete_PamVMCNDSD(void *p) {
      delete ((::PamVMCNDSD*)p);
   }
   static void deleteArray_PamVMCNDSD(void *p) {
      delete [] ((::PamVMCNDSD*)p);
   }
   static void destruct_PamVMCNDSD(void *p) {
      typedef ::PamVMCNDSD current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::PamVMCNDSD

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

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

//______________________________________________________________________________
void pHitData::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class pHitData.
      TClass *R__cl = ::pHitData::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fPOS", &fPOS);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fPDG", &fPDG);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fPATH", &fPATH);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTOF", &fTOF);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fPIN", &fPIN);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fXOUT", &fXOUT);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fYOUT", &fYOUT);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fZOUT", &fZOUT);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fEREL", &fEREL);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fXIN", &fXIN);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fYIN", &fYIN);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fZIN", &fZIN);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fPRIM", &fPRIM);
      TObject::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_pHitData(void *p) {
      return  p ? new(p) ::pHitData : new ::pHitData;
   }
   static void *newArray_pHitData(Long_t nElements, void *p) {
      return p ? new(p) ::pHitData[nElements] : new ::pHitData[nElements];
   }
   // Wrapper around operator delete
   static void delete_pHitData(void *p) {
      delete ((::pHitData*)p);
   }
   static void deleteArray_pHitData(void *p) {
      delete [] ((::pHitData*)p);
   }
   static void destruct_pHitData(void *p) {
      typedef ::pHitData current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::pHitData

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

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

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_pTrkHitData(void *p) {
      return  p ? new(p) ::pTrkHitData : new ::pTrkHitData;
   }
   static void *newArray_pTrkHitData(Long_t nElements, void *p) {
      return p ? new(p) ::pTrkHitData[nElements] : new ::pTrkHitData[nElements];
   }
   // Wrapper around operator delete
   static void delete_pTrkHitData(void *p) {
      delete ((::pTrkHitData*)p);
   }
   static void deleteArray_pTrkHitData(void *p) {
      delete [] ((::pTrkHitData*)p);
   }
   static void destruct_pTrkHitData(void *p) {
      typedef ::pTrkHitData current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::pTrkHitData

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

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

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_pGPSSPEHits(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::pGPSSPEHits : new ::pGPSSPEHits;
   }
   static void *newArray_pGPSSPEHits(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::pGPSSPEHits[nElements] : new ::pGPSSPEHits[nElements];
   }
   // Wrapper around operator delete
   static void delete_pGPSSPEHits(void *p) {
      delete ((::pGPSSPEHits*)p);
   }
   static void deleteArray_pGPSSPEHits(void *p) {
      delete [] ((::pGPSSPEHits*)p);
   }
   static void destruct_pGPSSPEHits(void *p) {
      typedef ::pGPSSPEHits current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::pGPSSPEHits

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

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

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_GPSSPEData(void *p) {
      return  p ? new(p) ::GPSSPEData : new ::GPSSPEData;
   }
   static void *newArray_GPSSPEData(Long_t nElements, void *p) {
      return p ? new(p) ::GPSSPEData[nElements] : new ::GPSSPEData[nElements];
   }
   // Wrapper around operator delete
   static void delete_GPSSPEData(void *p) {
      delete ((::GPSSPEData*)p);
   }
   static void deleteArray_GPSSPEData(void *p) {
      delete [] ((::GPSSPEData*)p);
   }
   static void destruct_GPSSPEData(void *p) {
      typedef ::GPSSPEData current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::GPSSPEData

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

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

//______________________________________________________________________________
void PamVMCDigitizer::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class PamVMCDigitizer.
      TClass *R__cl = ::PamVMCDigitizer::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fdname", &fdname);
      R__insp.InspectMember(fdname, "fdname.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fsql", &fsql);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fraw", &fraw);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*frnd", &frnd);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*frandom", &frandom);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fcfile", (void*)&fcfile);
      R__insp.InspectMember("ifstream", (void*)&fcfile, "fcfile.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fquery", (void*)&fquery);
      R__insp.InspectMember("stringstream", (void*)&fquery, "fquery.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fdberr", &fdberr);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fpath", &fpath);
      R__insp.InspectMember(fpath, "fpath.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fcrfile", &fcrfile);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fhitscolmap", &fhitscolmap);
      R__insp.InspectMember(fhitscolmap, "fhitscolmap.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fData", (void*)&fData);
      R__insp.InspectMember("USBuffer", (void*)&fData, "fData.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fDataPSCU", (void*)&fDataPSCU);
      R__insp.InspectMember("UCBuffer", (void*)&fDataPSCU, "fDataPSCU.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fPadding", &fPadding);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fDataPadding", (void*)&fDataPadding);
      R__insp.InspectMember("UCBuffer", (void*)&fDataPadding, "fDataPadding.", false);
      TObject::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrapper around operator delete
   static void delete_PamVMCDigitizer(void *p) {
      delete ((::PamVMCDigitizer*)p);
   }
   static void deleteArray_PamVMCDigitizer(void *p) {
      delete [] ((::PamVMCDigitizer*)p);
   }
   static void destruct_PamVMCDigitizer(void *p) {
      typedef ::PamVMCDigitizer current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::PamVMCDigitizer

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

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

//______________________________________________________________________________
void PamVMCTrkDig::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class PamVMCTrkDig.
      TClass *R__cl = ::PamVMCTrkDig::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fSigmaTrack[12][3072]", fSigmaTrack);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fPedeTrack[12][3072]", fPedeTrack);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "AdcTrack[12][3072]", AdcTrack);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMipCor[3][12]", fMipCor);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fextrnd", &fextrnd);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fhits", &fhits);
      PamVMCDigitizer::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_PamVMCTrkDig(void *p) {
      return  p ? new(p) ::PamVMCTrkDig : new ::PamVMCTrkDig;
   }
   static void *newArray_PamVMCTrkDig(Long_t nElements, void *p) {
      return p ? new(p) ::PamVMCTrkDig[nElements] : new ::PamVMCTrkDig[nElements];
   }
   // Wrapper around operator delete
   static void delete_PamVMCTrkDig(void *p) {
      delete ((::PamVMCTrkDig*)p);
   }
   static void deleteArray_PamVMCTrkDig(void *p) {
      delete [] ((::PamVMCTrkDig*)p);
   }
   static void destruct_PamVMCTrkDig(void *p) {
      typedef ::PamVMCTrkDig current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::PamVMCTrkDig

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

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

//______________________________________________________________________________
void PamVMCTofDig::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class PamVMCTofDig.
      TClass *R__cl = ::PamVMCTofDig::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fatte1[48]", fatte1);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fatte2[48]", fatte2);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "flambda1[48]", flambda1);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "flambda2[48]", flambda2);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fQevePmt_pC[48]", fQevePmt_pC);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fADCtof[48]", fADCtof);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTDCint[48]", fTDCint);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "ftdcres[48]", ftdcres);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fc1_S[48]", fc1_S);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fc2_S[48]", fc2_S);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fc3_S[48]", fc3_S);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "ftdc[48]", ftdc);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "ftdc1[48]", ftdc1);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "ftdcpmt[48]", ftdcpmt);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fDEBUG", &fDEBUG);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fDataC", (void*)&fDataC);
      R__insp.InspectMember("UCBuffer", (void*)&fDataC, "fDataC.", false);
      PamVMCDigitizer::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_PamVMCTofDig(void *p) {
      return  p ? new(p) ::PamVMCTofDig : new ::PamVMCTofDig;
   }
   static void *newArray_PamVMCTofDig(Long_t nElements, void *p) {
      return p ? new(p) ::PamVMCTofDig[nElements] : new ::PamVMCTofDig[nElements];
   }
   // Wrapper around operator delete
   static void delete_PamVMCTofDig(void *p) {
      delete ((::PamVMCTofDig*)p);
   }
   static void deleteArray_PamVMCTofDig(void *p) {
      delete [] ((::PamVMCTofDig*)p);
   }
   static void destruct_PamVMCTofDig(void *p) {
      typedef ::PamVMCTofDig current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::PamVMCTofDig

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

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

//______________________________________________________________________________
void PamVMCAcDig::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class PamVMCAcDig.
      TClass *R__cl = ::PamVMCAcDig::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fSumEcat[5]", fSumEcat);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fSumEcas[5]", fSumEcas);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fSumEcard[5]", fSumEcard);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fDEBUG", &fDEBUG);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fattenAC", &fattenAC);
      PamVMCDigitizer::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_PamVMCAcDig(void *p) {
      return  p ? new(p) ::PamVMCAcDig : new ::PamVMCAcDig;
   }
   static void *newArray_PamVMCAcDig(Long_t nElements, void *p) {
      return p ? new(p) ::PamVMCAcDig[nElements] : new ::PamVMCAcDig[nElements];
   }
   // Wrapper around operator delete
   static void delete_PamVMCAcDig(void *p) {
      delete ((::PamVMCAcDig*)p);
   }
   static void deleteArray_PamVMCAcDig(void *p) {
      delete [] ((::PamVMCAcDig*)p);
   }
   static void destruct_PamVMCAcDig(void *p) {
      typedef ::PamVMCAcDig current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::PamVMCAcDig

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

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

//______________________________________________________________________________
void PamVMCCaloDig::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class PamVMCCaloDig.
      TClass *R__cl = ::PamVMCCaloDig::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fCalomip[2][22][96]", fCalomip);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fcalped[4][11][96]", fcalped);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fcalgood[4][11][96]", fcalgood);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fcalthr[4][11][6]", fcalthr);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fcalrms[4][11][96]", fcalrms);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fcalbase[4][11][6]", fcalbase);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fcalvar[4][11][6]", fcalvar);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fcstwerr[4]", fcstwerr);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fcperror[4]", fcperror);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fevtcalo", &fevtcalo);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fSecCalo[4]", fSecCalo);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fSecCaloLength[4]", fSecCaloLength);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fhc", &fhc);
      PamVMCDigitizer::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_PamVMCCaloDig(void *p) {
      return  p ? new(p) ::PamVMCCaloDig : new ::PamVMCCaloDig;
   }
   static void *newArray_PamVMCCaloDig(Long_t nElements, void *p) {
      return p ? new(p) ::PamVMCCaloDig[nElements] : new ::PamVMCCaloDig[nElements];
   }
   // Wrapper around operator delete
   static void delete_PamVMCCaloDig(void *p) {
      delete ((::PamVMCCaloDig*)p);
   }
   static void deleteArray_PamVMCCaloDig(void *p) {
      delete [] ((::PamVMCCaloDig*)p);
   }
   static void destruct_PamVMCCaloDig(void *p) {
      typedef ::PamVMCCaloDig current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::PamVMCCaloDig

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

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

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_PamVMCS4Dig(void *p) {
      return  p ? new(p) ::PamVMCS4Dig : new ::PamVMCS4Dig;
   }
   static void *newArray_PamVMCS4Dig(Long_t nElements, void *p) {
      return p ? new(p) ::PamVMCS4Dig[nElements] : new ::PamVMCS4Dig[nElements];
   }
   // Wrapper around operator delete
   static void delete_PamVMCS4Dig(void *p) {
      delete ((::PamVMCS4Dig*)p);
   }
   static void deleteArray_PamVMCS4Dig(void *p) {
      delete [] ((::PamVMCS4Dig*)p);
   }
   static void destruct_PamVMCS4Dig(void *p) {
      typedef ::PamVMCS4Dig current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::PamVMCS4Dig

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

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

//______________________________________________________________________________
void PamVMCNDDig::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class PamVMCNDDig.
      TClass *R__cl = ::PamVMCNDDig::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fpHits", (void*)&fpHits);
      R__insp.InspectMember("pHits", (void*)&fpHits, "fpHits.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "tauHits[36]", tauHits);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "tubeHits[36]", tubeHits);
      PamVMCDigitizer::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_PamVMCNDDig(void *p) {
      return  p ? new(p) ::PamVMCNDDig : new ::PamVMCNDDig;
   }
   static void *newArray_PamVMCNDDig(Long_t nElements, void *p) {
      return p ? new(p) ::PamVMCNDDig[nElements] : new ::PamVMCNDDig[nElements];
   }
   // Wrapper around operator delete
   static void delete_PamVMCNDDig(void *p) {
      delete ((::PamVMCNDDig*)p);
   }
   static void deleteArray_PamVMCNDDig(void *p) {
      delete [] ((::PamVMCNDDig*)p);
   }
   static void destruct_PamVMCNDDig(void *p) {
      typedef ::PamVMCNDDig current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::PamVMCNDDig

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

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

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

namespace ROOT {
   // Wrapper around operator delete
   static void delete_PamVMCOptMgr(void *p) {
      delete ((::PamVMCOptMgr*)p);
   }
   static void deleteArray_PamVMCOptMgr(void *p) {
      delete [] ((::PamVMCOptMgr*)p);
   }
   static void destruct_PamVMCOptMgr(void *p) {
      typedef ::PamVMCOptMgr current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::PamVMCOptMgr

namespace ROOT {
   void maplEintcOpCombTransmUgR_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void maplEintcOpCombTransmUgR_Dictionary();
   static void *new_maplEintcOpCombTransmUgR(void *p = 0);
   static void *newArray_maplEintcOpCombTransmUgR(Long_t size, void *p);
   static void delete_maplEintcOpCombTransmUgR(void *p);
   static void deleteArray_maplEintcOpCombTransmUgR(void *p);
   static void destruct_maplEintcOpCombTransmUgR(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const map<int,pCombTrans*>*)
   {
      map<int,pCombTrans*> *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(map<int,pCombTrans*>),0);
      static ::ROOT::TGenericClassInfo 
         instance("map<int,pCombTrans*>", -2, "prec_stl/map", 63,
                  typeid(map<int,pCombTrans*>), DefineBehavior(ptr, ptr),
                  0, &maplEintcOpCombTransmUgR_Dictionary, isa_proxy, 0,
                  sizeof(map<int,pCombTrans*>) );
      instance.SetNew(&new_maplEintcOpCombTransmUgR);
      instance.SetNewArray(&newArray_maplEintcOpCombTransmUgR);
      instance.SetDelete(&delete_maplEintcOpCombTransmUgR);
      instance.SetDeleteArray(&deleteArray_maplEintcOpCombTransmUgR);
      instance.SetDestructor(&destruct_maplEintcOpCombTransmUgR);
      instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::MapInsert< map<int,pCombTrans*> >()));
      return &instance;
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const map<int,pCombTrans*>*)0x0); R__UseDummy(_R__UNIQUE_(Init));

   // Dictionary for non-ClassDef classes
   static void maplEintcOpCombTransmUgR_Dictionary() {
      ::ROOT::GenerateInitInstanceLocal((const map<int,pCombTrans*>*)0x0)->GetClass();
   }

} // end of namespace ROOT

namespace ROOT {
   // Wrappers around operator new
   static void *new_maplEintcOpCombTransmUgR(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) map<int,pCombTrans*> : new map<int,pCombTrans*>;
   }
   static void *newArray_maplEintcOpCombTransmUgR(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) map<int,pCombTrans*>[nElements] : new map<int,pCombTrans*>[nElements];
   }
   // Wrapper around operator delete
   static void delete_maplEintcOpCombTransmUgR(void *p) {
      delete ((map<int,pCombTrans*>*)p);
   }
   static void deleteArray_maplEintcOpCombTransmUgR(void *p) {
      delete [] ((map<int,pCombTrans*>*)p);
   }
   static void destruct_maplEintcOpCombTransmUgR(void *p) {
      typedef map<int,pCombTrans*> current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class map<int,pCombTrans*>

namespace ROOT {
   void vectorlEPamVMCDetectorHitmUgR_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void vectorlEPamVMCDetectorHitmUgR_Dictionary();
   static void *new_vectorlEPamVMCDetectorHitmUgR(void *p = 0);
   static void *newArray_vectorlEPamVMCDetectorHitmUgR(Long_t size, void *p);
   static void delete_vectorlEPamVMCDetectorHitmUgR(void *p);
   static void deleteArray_vectorlEPamVMCDetectorHitmUgR(void *p);
   static void destruct_vectorlEPamVMCDetectorHitmUgR(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const vector<PamVMCDetectorHit*>*)
   {
      vector<PamVMCDetectorHit*> *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(vector<PamVMCDetectorHit*>),0);
      static ::ROOT::TGenericClassInfo 
         instance("vector<PamVMCDetectorHit*>", -2, "prec_stl/vector", 49,
                  typeid(vector<PamVMCDetectorHit*>), DefineBehavior(ptr, ptr),
                  0, &vectorlEPamVMCDetectorHitmUgR_Dictionary, isa_proxy, 0,
                  sizeof(vector<PamVMCDetectorHit*>) );
      instance.SetNew(&new_vectorlEPamVMCDetectorHitmUgR);
      instance.SetNewArray(&newArray_vectorlEPamVMCDetectorHitmUgR);
      instance.SetDelete(&delete_vectorlEPamVMCDetectorHitmUgR);
      instance.SetDeleteArray(&deleteArray_vectorlEPamVMCDetectorHitmUgR);
      instance.SetDestructor(&destruct_vectorlEPamVMCDetectorHitmUgR);
      instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::Pushback< vector<PamVMCDetectorHit*> >()));
      return &instance;
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const vector<PamVMCDetectorHit*>*)0x0); R__UseDummy(_R__UNIQUE_(Init));

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

} // end of namespace ROOT

namespace ROOT {
   // Wrappers around operator new
   static void *new_vectorlEPamVMCDetectorHitmUgR(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) vector<PamVMCDetectorHit*> : new vector<PamVMCDetectorHit*>;
   }
   static void *newArray_vectorlEPamVMCDetectorHitmUgR(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) vector<PamVMCDetectorHit*>[nElements] : new vector<PamVMCDetectorHit*>[nElements];
   }
   // Wrapper around operator delete
   static void delete_vectorlEPamVMCDetectorHitmUgR(void *p) {
      delete ((vector<PamVMCDetectorHit*>*)p);
   }
   static void deleteArray_vectorlEPamVMCDetectorHitmUgR(void *p) {
      delete [] ((vector<PamVMCDetectorHit*>*)p);
   }
   static void destruct_vectorlEPamVMCDetectorHitmUgR(void *p) {
      typedef vector<PamVMCDetectorHit*> current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class vector<PamVMCDetectorHit*>

namespace ROOT {
   void vectorlEdoublegR_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void vectorlEdoublegR_Dictionary();
   static void *new_vectorlEdoublegR(void *p = 0);
   static void *newArray_vectorlEdoublegR(Long_t size, void *p);
   static void delete_vectorlEdoublegR(void *p);
   static void deleteArray_vectorlEdoublegR(void *p);
   static void destruct_vectorlEdoublegR(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const vector<double>*)
   {
      vector<double> *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(vector<double>),0);
      static ::ROOT::TGenericClassInfo 
         instance("vector<double>", -2, "vector.dll", 0,
                  typeid(vector<double>), DefineBehavior(ptr, ptr),
                  0, &vectorlEdoublegR_Dictionary, isa_proxy, 0,
                  sizeof(vector<double>) );
      instance.SetNew(&new_vectorlEdoublegR);
      instance.SetNewArray(&newArray_vectorlEdoublegR);
      instance.SetDelete(&delete_vectorlEdoublegR);
      instance.SetDeleteArray(&deleteArray_vectorlEdoublegR);
      instance.SetDestructor(&destruct_vectorlEdoublegR);
      instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::Pushback< vector<double> >()));
      return &instance;
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const vector<double>*)0x0); R__UseDummy(_R__UNIQUE_(Init));

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

} // end of namespace ROOT

namespace ROOT {
   // Wrappers around operator new
   static void *new_vectorlEdoublegR(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) vector<double> : new vector<double>;
   }
   static void *newArray_vectorlEdoublegR(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) vector<double>[nElements] : new vector<double>[nElements];
   }
   // Wrapper around operator delete
   static void delete_vectorlEdoublegR(void *p) {
      delete ((vector<double>*)p);
   }
   static void deleteArray_vectorlEdoublegR(void *p) {
      delete [] ((vector<double>*)p);
   }
   static void destruct_vectorlEdoublegR(void *p) {
      typedef vector<double> current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class vector<double>

namespace ROOT {
   void vectorlEunsignedsPchargR_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void vectorlEunsignedsPchargR_Dictionary();
   static void *new_vectorlEunsignedsPchargR(void *p = 0);
   static void *newArray_vectorlEunsignedsPchargR(Long_t size, void *p);
   static void delete_vectorlEunsignedsPchargR(void *p);
   static void deleteArray_vectorlEunsignedsPchargR(void *p);
   static void destruct_vectorlEunsignedsPchargR(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const vector<unsigned char>*)
   {
      vector<unsigned char> *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(vector<unsigned char>),0);
      static ::ROOT::TGenericClassInfo 
         instance("vector<unsigned char>", -2, "vector.dll", 0,
                  typeid(vector<unsigned char>), DefineBehavior(ptr, ptr),
                  0, &vectorlEunsignedsPchargR_Dictionary, isa_proxy, 0,
                  sizeof(vector<unsigned char>) );
      instance.SetNew(&new_vectorlEunsignedsPchargR);
      instance.SetNewArray(&newArray_vectorlEunsignedsPchargR);
      instance.SetDelete(&delete_vectorlEunsignedsPchargR);
      instance.SetDeleteArray(&deleteArray_vectorlEunsignedsPchargR);
      instance.SetDestructor(&destruct_vectorlEunsignedsPchargR);
      instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::Pushback< vector<unsigned char> >()));
      return &instance;
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const vector<unsigned char>*)0x0); R__UseDummy(_R__UNIQUE_(Init));

   // Dictionary for non-ClassDef classes
   static void vectorlEunsignedsPchargR_Dictionary() {
      ::ROOT::GenerateInitInstanceLocal((const vector<unsigned char>*)0x0)->GetClass();
   }

} // end of namespace ROOT

namespace ROOT {
   // Wrappers around operator new
   static void *new_vectorlEunsignedsPchargR(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) vector<unsigned char> : new vector<unsigned char>;
   }
   static void *newArray_vectorlEunsignedsPchargR(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) vector<unsigned char>[nElements] : new vector<unsigned char>[nElements];
   }
   // Wrapper around operator delete
   static void delete_vectorlEunsignedsPchargR(void *p) {
      delete ((vector<unsigned char>*)p);
   }
   static void deleteArray_vectorlEunsignedsPchargR(void *p) {
      delete [] ((vector<unsigned char>*)p);
   }
   static void destruct_vectorlEunsignedsPchargR(void *p) {
      typedef vector<unsigned char> current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class vector<unsigned char>

namespace ROOT {
   void vectorlEunsignedsPshortgR_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void vectorlEunsignedsPshortgR_Dictionary();
   static void *new_vectorlEunsignedsPshortgR(void *p = 0);
   static void *newArray_vectorlEunsignedsPshortgR(Long_t size, void *p);
   static void delete_vectorlEunsignedsPshortgR(void *p);
   static void deleteArray_vectorlEunsignedsPshortgR(void *p);
   static void destruct_vectorlEunsignedsPshortgR(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const vector<unsigned short>*)
   {
      vector<unsigned short> *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(vector<unsigned short>),0);
      static ::ROOT::TGenericClassInfo 
         instance("vector<unsigned short>", -2, "vector.dll", 0,
                  typeid(vector<unsigned short>), DefineBehavior(ptr, ptr),
                  0, &vectorlEunsignedsPshortgR_Dictionary, isa_proxy, 0,
                  sizeof(vector<unsigned short>) );
      instance.SetNew(&new_vectorlEunsignedsPshortgR);
      instance.SetNewArray(&newArray_vectorlEunsignedsPshortgR);
      instance.SetDelete(&delete_vectorlEunsignedsPshortgR);
      instance.SetDeleteArray(&deleteArray_vectorlEunsignedsPshortgR);
      instance.SetDestructor(&destruct_vectorlEunsignedsPshortgR);
      instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::Pushback< vector<unsigned short> >()));
      return &instance;
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const vector<unsigned short>*)0x0); R__UseDummy(_R__UNIQUE_(Init));

   // Dictionary for non-ClassDef classes
   static void vectorlEunsignedsPshortgR_Dictionary() {
      ::ROOT::GenerateInitInstanceLocal((const vector<unsigned short>*)0x0)->GetClass();
   }

} // end of namespace ROOT

namespace ROOT {
   // Wrappers around operator new
   static void *new_vectorlEunsignedsPshortgR(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) vector<unsigned short> : new vector<unsigned short>;
   }
   static void *newArray_vectorlEunsignedsPshortgR(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) vector<unsigned short>[nElements] : new vector<unsigned short>[nElements];
   }
   // Wrapper around operator delete
   static void delete_vectorlEunsignedsPshortgR(void *p) {
      delete ((vector<unsigned short>*)p);
   }
   static void deleteArray_vectorlEunsignedsPshortgR(void *p) {
      delete [] ((vector<unsigned short>*)p);
   }
   static void destruct_vectorlEunsignedsPshortgR(void *p) {
      typedef vector<unsigned short> current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class vector<unsigned short>

/********************************************************
* /home/formato/scratch/devel/VirtualMC/SIM_VMC/PamVMC/tmp/tgt_linux/PamVMC_fc/PamVMC_fcCint.cxx
* CAUTION: DON'T CHANGE THIS FILE. THIS FILE IS AUTOMATICALLY GENERATED
*          FROM HEADER FILES LISTED IN G__setup_cpp_environmentXXX().
*          CHANGE THOSE HEADER FILES AND REGENERATE THIS FILE.
********************************************************/

#ifdef G__MEMTEST
#undef malloc
#undef free
#endif

#if defined(__GNUC__) && __GNUC__ >= 4 && ((__GNUC_MINOR__ == 2 && __GNUC_PATCHLEVEL__ >= 1) || (__GNUC_MINOR__ >= 3))
#pragma GCC diagnostic ignored "-Wstrict-aliasing"
#endif

extern "C" void G__cpp_reset_tagtablePamVMC_fcCint();

extern "C" void G__set_cpp_environmentPamVMC_fcCint() {
  G__add_compiledheader("TObject.h");
  G__add_compiledheader("TMemberInspector.h");
  G__add_compiledheader("include/CRC.h");
  G__add_compiledheader("include/PamRootManager.h");
  G__add_compiledheader("include/PamVMC2PiAux.h");
  G__add_compiledheader("include/PamVMCApplication.h");
  G__add_compiledheader("include/PamVMCCutContMgr.h");
  G__add_compiledheader("include/PamVMCDetector.h");
  G__add_compiledheader("include/PamVMCDetectorHit.h");
  G__add_compiledheader("include/PamVMCDetectorSD.h");
  G__add_compiledheader("include/PamVMCDetGeom.h");
  G__add_compiledheader("include/PamVMCDetPamela.h");
  G__add_compiledheader("include/PamVMCDigitizer.h");
  G__add_compiledheader("include/PamVMCDigMgr.h");
  G__add_compiledheader("include/PamVMCFieldMgr.h");
  G__add_compiledheader("include/PamVMCGeoID.h");
  G__add_compiledheader("include/PamVMCGeoIDMgr.h");
  G__add_compiledheader("include/PamVMCGeoRotMgr.h");
  G__add_compiledheader("include/PamVMCMat.h");
  G__add_compiledheader("include/PamVMCOptions.h");
  G__add_compiledheader("include/PamVMCOptMgr.h");
  G__add_compiledheader("include/PamVMCParticle.h");
  G__add_compiledheader("include/PamVMCPrimaryGenerator.h");
  G__add_compiledheader("include/PamVMCPrimaryGF.h");
  G__add_compiledheader("include/PamVMCRawMgr.h");
  G__add_compiledheader("include/PamVMCRndMgr.h");
  G__add_compiledheader("include/PamVMCSDMgr.h");
  G__add_compiledheader("include/PamVMCSQLMgr.h");
  G__add_compiledheader("include/PamVMCStack.h");
  G__add_compiledheader("include/pCutControl.h");
  G__add_compiledheader("include/pGeoID.h");
  G__add_compiledheader("cal/include/PamVMCCaloDig.h");
  G__add_compiledheader("cal/include/PamVMCCaloID.h");
  G__add_compiledheader("cal/include/PamVMCCaloSD.h");
  G__add_compiledheader("cal/include/PamVMCDetCalo.h");
  G__add_compiledheader("trk/include/PamVMCDetTrk.h");
  G__add_compiledheader("trk/include/PamVMCTrkDig.h");
  G__add_compiledheader("trk/include/PamVMCTrkF77GpcSpe.h");
  G__add_compiledheader("trk/include/PamVMCTrkF77GpsSpe.h");
  G__add_compiledheader("trk/include/PamVMCTrkF77.h");
  G__add_compiledheader("trk/include/PamVMCTrkHit.h");
  G__add_compiledheader("trk/include/PamVMCTrkID.h");
  G__add_compiledheader("trk/include/PamVMCTrkSD.h");
  G__add_compiledheader("trk/include/pCombTrans.h");
  G__add_compiledheader("tof/include/PamVMCDetTof.h");
  G__add_compiledheader("tof/include/PamVMCDetTofS1.h");
  G__add_compiledheader("tof/include/PamVMCDetTofS2.h");
  G__add_compiledheader("tof/include/PamVMCDetTofS3.h");
  G__add_compiledheader("tof/include/PamVMCTofDig.h");
  G__add_compiledheader("tof/include/PamVMCTofID.h");
  G__add_compiledheader("tof/include/PamVMCTofSD.h");
  G__add_compiledheader("ac/include/PamVMCAcDig.h");
  G__add_compiledheader("ac/include/PamVMCCardID.h");
  G__add_compiledheader("ac/include/PamVMCCardSD.h");
  G__add_compiledheader("ac/include/PamVMCCasID.h");
  G__add_compiledheader("ac/include/PamVMCCasSD.h");
  G__add_compiledheader("ac/include/PamVMCCatID.h");
  G__add_compiledheader("ac/include/PamVMCCatSD.h");
  G__add_compiledheader("ac/include/PamVMCDetAc.h");
  G__add_compiledheader("ac/include/PamVMCDetCard.h");
  G__add_compiledheader("ac/include/PamVMCDetCas.h");
  G__add_compiledheader("ac/include/PamVMCDetCat.h");
  G__add_compiledheader("s4/include/PamVMCDetS4.h");
  G__add_compiledheader("s4/include/PamVMCS4Dig.h");
  G__add_compiledheader("s4/include/PamVMCS4ID.h");
  G__add_compiledheader("s4/include/PamVMCS4SD.h");
  G__add_compiledheader("nd/include/PamVMCDetND.h");
  G__add_compiledheader("nd/include/PamVMCNDDig.h");
  G__add_compiledheader("nd/include/PamVMCNDID.h");
  G__add_compiledheader("nd/include/PamVMCNDSD.h");
  G__cpp_reset_tagtablePamVMC_fcCint();
}
#include <new>
extern "C" int G__cpp_dllrevPamVMC_fcCint() { return(30051515); }

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

/* PamRootManager */
static int G__PamVMC_fcCint_529_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   PamRootManager* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 2
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new PamRootManager((const char*) G__int(libp->para[0]), (FileMode) G__int(libp->para[1]));
   } else {
     p = new((void*) gvp) PamRootManager((const char*) G__int(libp->para[0]), (FileMode) G__int(libp->para[1]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__PamVMC_fcCintLN_PamRootManager));
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__PamVMC_fcCint_529_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) PamRootManager::Instance());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_529_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((PamRootManager*) G__getstructoffset())->Register((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (void*) G__int(libp->para[2]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

static int G__PamVMC_fcCint_529_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) PamRootManager::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_529_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) PamRootManager::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_529_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) PamRootManager::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_529_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      PamRootManager::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__PamVMC_fcCint_529_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) PamRootManager::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_529_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) PamRootManager::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_529_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) PamRootManager::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_529_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) PamRootManager::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__PamVMC_fcCint_529_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   PamRootManager* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new PamRootManager(*(PamRootManager*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__PamVMC_fcCintLN_PamRootManager));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef PamRootManager G__TPamRootManager;
static int G__PamVMC_fcCint_529_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (PamRootManager*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((PamRootManager*) (soff+(sizeof(PamRootManager)*i)))->~G__TPamRootManager();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (PamRootManager*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((PamRootManager*) (soff))->~G__TPamRootManager();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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


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

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

static int G__PamVMC_fcCint_614_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) pHitData::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_614_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) pHitData::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_614_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) pHitData::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_614_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      pHitData::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__PamVMC_fcCint_614_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) pHitData::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_614_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) pHitData::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_614_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) pHitData::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_614_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) pHitData::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__PamVMC_fcCint_614_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   pHitData* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new pHitData(*(pHitData*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__PamVMC_fcCintLN_pHitData));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef pHitData G__TpHitData;
static int G__PamVMC_fcCint_614_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (pHitData*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((pHitData*) (soff+(sizeof(pHitData)*i)))->~G__TpHitData();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (pHitData*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((pHitData*) (soff))->~G__TpHitData();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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


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

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

static int G__PamVMC_fcCint_615_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((PamVMCDetectorHit*) G__getstructoffset())->GenHit());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_615_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((PamVMCDetectorHit*) G__getstructoffset())->operator=(*(PamVMCDetectorHit*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_615_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((PamVMCDetectorHit*) G__getstructoffset())->operator+=(*(PamVMCDetectorHit*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_615_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((PamVMCDetectorHit*) G__getstructoffset())->FillHitEntering(*(pHitData*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_615_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((PamVMCDetectorHit*) G__getstructoffset())->FillHit((TVirtualMC*) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_615_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((PamVMCDetectorHit*) G__getstructoffset())->SetHit(*(pHitData*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

static int G__PamVMC_fcCint_615_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((PamVMCDetectorHit*) G__getstructoffset())->GetHit());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_615_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((PamVMCDetectorHit*) G__getstructoffset())->GetPOS());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_615_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((PamVMCDetectorHit*) G__getstructoffset())->GetPDG());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_615_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((PamVMCDetectorHit*) G__getstructoffset())->GetPATH());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_615_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((PamVMCDetectorHit*) G__getstructoffset())->GetEREL());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_615_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((PamVMCDetectorHit*) G__getstructoffset())->GetXIN());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_615_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((PamVMCDetectorHit*) G__getstructoffset())->GetYIN());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_615_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((PamVMCDetectorHit*) G__getstructoffset())->GetZIN());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_615_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((PamVMCDetectorHit*) G__getstructoffset())->GetTOF());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_615_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((PamVMCDetectorHit*) G__getstructoffset())->GetPIN());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_615_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((PamVMCDetectorHit*) G__getstructoffset())->GetXOUT());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_615_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((PamVMCDetectorHit*) G__getstructoffset())->GetYOUT());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_615_0_42(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((PamVMCDetectorHit*) G__getstructoffset())->GetZOUT());
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__PamVMC_fcCint_615_0_45(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) PamVMCDetectorHit::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_615_0_46(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) PamVMCDetectorHit::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_615_0_47(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) PamVMCDetectorHit::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_615_0_48(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      PamVMCDetectorHit::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__PamVMC_fcCint_615_0_53(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) PamVMCDetectorHit::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_615_0_54(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) PamVMCDetectorHit::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_615_0_55(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) PamVMCDetectorHit::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_615_0_56(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) PamVMCDetectorHit::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__PamVMC_fcCint_615_0_57(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   PamVMCDetectorHit* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new PamVMCDetectorHit(*(PamVMCDetectorHit*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__PamVMC_fcCintLN_PamVMCDetectorHit));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef PamVMCDetectorHit G__TPamVMCDetectorHit;
static int G__PamVMC_fcCint_615_0_58(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (PamVMCDetectorHit*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((PamVMCDetectorHit*) (soff+(sizeof(PamVMCDetectorHit)*i)))->~G__TPamVMCDetectorHit();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (PamVMCDetectorHit*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((PamVMCDetectorHit*) (soff))->~G__TPamVMCDetectorHit();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* PamVMCOptMgr */
static int G__PamVMC_fcCint_822_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) PamVMCOptMgr::Instance());
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__PamVMC_fcCint_822_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((PamVMCOptMgr*) G__getstructoffset())->ParseFile(*((TString*) G__int(libp->para[0]))));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_822_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TString* pobj;
         TString xobj = ((PamVMCOptMgr*) G__getstructoffset())->GetOutPath();
         pobj = new TString(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_822_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TString* pobj;
         TString xobj = ((PamVMCOptMgr*) G__getstructoffset())->GetOutPattern();
         pobj = new TString(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_822_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TString* pobj;
         TString xobj = ((PamVMCOptMgr*) G__getstructoffset())->GetOutPatternFull();
         pobj = new TString(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_822_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TString* pobj;
         TString xobj = ((PamVMCOptMgr*) G__getstructoffset())->GetTmpPath();
         pobj = new TString(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

static int G__PamVMC_fcCint_822_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TString* pobj;
         TString xobj = ((PamVMCOptMgr*) G__getstructoffset())->GetG4ConfigC();
         pobj = new TString(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_822_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TString* pobj;
         TString xobj = ((PamVMCOptMgr*) G__getstructoffset())->GetG4ConfigIn();
         pobj = new TString(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

static int G__PamVMC_fcCint_822_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((PamVMCOptMgr*) G__getstructoffset())->GetUserRandomSeed(*(Int_t*) G__Intref(&libp->para[0]), *(Int_t*) G__Intref(&libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__PamVMC_fcCint_822_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TString* pobj;
         TString xobj = ((PamVMCOptMgr*) G__getstructoffset())->GetRandomOutFile();
         pobj = new TString(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_822_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TString* pobj;
         TString xobj = ((PamVMCOptMgr*) G__getstructoffset())->GetRandomOutFilename();
         pobj = new TString(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_822_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TString* pobj;
         TString xobj = ((PamVMCOptMgr*) G__getstructoffset())->GetRandomInFilename();
         pobj = new TString(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_822_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((PamVMCOptMgr*) G__getstructoffset())->GetVerboseLevel());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_822_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((PamVMCOptMgr*) G__getstructoffset())->GetMaxSteps());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_822_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((PamVMCOptMgr*) G__getstructoffset())->GetSaveCond());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_822_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((PamVMCOptMgr*) G__getstructoffset())->GetSaveMode());
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__PamVMC_fcCint_822_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TString* pobj;
         TString xobj = ((PamVMCOptMgr*) G__getstructoffset())->GetReadPrimPath();
         pobj = new TString(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_822_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((PamVMCOptMgr*) G__getstructoffset())->GetPrimPDG());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_822_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((PamVMCOptMgr*) G__getstructoffset())->GetPrimMomMode());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_822_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((PamVMCOptMgr*) G__getstructoffset())->GetPrimMomUnits());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_822_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((PamVMCOptMgr*) G__getstructoffset())->GetMomFixed());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_822_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((PamVMCOptMgr*) G__getstructoffset())->GetMomLimits(*(Double_t*) G__Doubleref(&libp->para[0]), *(Double_t*) G__Doubleref(&libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_822_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((PamVMCOptMgr*) G__getstructoffset())->GetMomGamma());
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

static int G__PamVMC_fcCint_822_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((PamVMCOptMgr*) G__getstructoffset())->GetFixedPointVertex(*(Double_t*) G__Doubleref(&libp->para[0]), *(Double_t*) G__Doubleref(&libp->para[1])
, *(Double_t*) G__Doubleref(&libp->para[2]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_822_0_42(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((PamVMCOptMgr*) G__getstructoffset())->GetBoxVertex(*(Double_t*) G__Doubleref(&libp->para[0]), *(Double_t*) G__Doubleref(&libp->para[1])
, *(Double_t*) G__Doubleref(&libp->para[2]), *(Double_t*) G__Doubleref(&libp->para[3])
, *(Double_t*) G__Doubleref(&libp->para[4]), *(Double_t*) G__Doubleref(&libp->para[5]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__PamVMC_fcCint_822_0_44(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((PamVMCOptMgr*) G__getstructoffset())->GetFixedAngles(*(Double_t*) G__Doubleref(&libp->para[0]), *(Double_t*) G__Doubleref(&libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_822_0_45(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((PamVMCOptMgr*) G__getstructoffset())->GetIsotropicAngles(*(Double_t*) G__Doubleref(&libp->para[0]), *(Double_t*) G__Doubleref(&libp->para[1])
, *(Double_t*) G__Doubleref(&libp->para[2]), *(Double_t*) G__Doubleref(&libp->para[3]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_822_0_46(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((PamVMCOptMgr*) G__getstructoffset())->GetStopMode());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_822_0_47(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((PamVMCOptMgr*) G__getstructoffset())->GetEvMax());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_822_0_48(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) PamVMCOptMgr::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_822_0_49(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) PamVMCOptMgr::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_822_0_50(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) PamVMCOptMgr::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_822_0_51(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      PamVMCOptMgr::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__PamVMC_fcCint_822_0_56(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) PamVMCOptMgr::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_822_0_57(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) PamVMCOptMgr::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_822_0_58(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) PamVMCOptMgr::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_822_0_59(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) PamVMCOptMgr::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef PamVMCOptMgr G__TPamVMCOptMgr;
static int G__PamVMC_fcCint_822_0_60(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (PamVMCOptMgr*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((PamVMCOptMgr*) (soff+(sizeof(PamVMCOptMgr)*i)))->~G__TPamVMCOptMgr();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (PamVMCOptMgr*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((PamVMCOptMgr*) (soff))->~G__TPamVMCOptMgr();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* PamVMCDigitizer */
static int G__PamVMC_fcCint_824_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((PamVMCDigitizer*) G__getstructoffset())->RegisterCollections((const char*) G__int(libp->para[0]), (TClonesArray*) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__PamVMC_fcCint_824_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((PamVMCDigitizer*) G__getstructoffset())->SetRandom((TRandom3*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

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

static int G__PamVMC_fcCint_824_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) PamVMCDigitizer::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_824_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) PamVMCDigitizer::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_824_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) PamVMCDigitizer::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_824_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      PamVMCDigitizer::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__PamVMC_fcCint_824_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) PamVMCDigitizer::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_824_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) PamVMCDigitizer::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_824_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) PamVMCDigitizer::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_824_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) PamVMCDigitizer::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef PamVMCDigitizer G__TPamVMCDigitizer;
static int G__PamVMC_fcCint_824_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (PamVMCDigitizer*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((PamVMCDigitizer*) (soff+(sizeof(PamVMCDigitizer)*i)))->~G__TPamVMCDigitizer();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (PamVMCDigitizer*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((PamVMCDigitizer*) (soff))->~G__TPamVMCDigitizer();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


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

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

static int G__PamVMC_fcCint_826_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) GPSSPEData::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_826_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) GPSSPEData::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_826_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) GPSSPEData::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_826_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      GPSSPEData::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__PamVMC_fcCint_826_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) GPSSPEData::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_826_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) GPSSPEData::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_826_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) GPSSPEData::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_826_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) GPSSPEData::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__PamVMC_fcCint_826_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   GPSSPEData* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new GPSSPEData(*(GPSSPEData*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__PamVMC_fcCintLN_GPSSPEData));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef GPSSPEData G__TGPSSPEData;
static int G__PamVMC_fcCint_826_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (GPSSPEData*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((GPSSPEData*) (soff+(sizeof(GPSSPEData)*i)))->~G__TGPSSPEData();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (GPSSPEData*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((GPSSPEData*) (soff))->~G__TGPSSPEData();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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


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

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

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

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

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

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

static int G__PamVMC_fcCint_827_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((pGPSSPEHits*) G__getstructoffset())->GetNXHit());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_827_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((pGPSSPEHits*) G__getstructoffset())->GetNYHit());
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

static int G__PamVMC_fcCint_827_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((pGPSSPEHits*) G__getstructoffset())->SetData((cGPSSPE*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__PamVMC_fcCint_827_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) pGPSSPEHits::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_827_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) pGPSSPEHits::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_827_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) pGPSSPEHits::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_827_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      pGPSSPEHits::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

static int G__PamVMC_fcCint_827_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) pGPSSPEHits::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_827_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) pGPSSPEHits::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_827_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) pGPSSPEHits::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_827_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) pGPSSPEHits::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__PamVMC_fcCint_827_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   pGPSSPEHits* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new pGPSSPEHits(*(pGPSSPEHits*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__PamVMC_fcCintLN_pGPSSPEHits));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef pGPSSPEHits G__TpGPSSPEHits;
static int G__PamVMC_fcCint_827_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 0
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (pGPSSPEHits*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((pGPSSPEHits*) (soff+(sizeof(pGPSSPEHits)*i)))->~G__TpGPSSPEHits();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (pGPSSPEHits*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((pGPSSPEHits*) (soff))->~G__TpGPSSPEHits();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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


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

static int G__PamVMC_fcCint_830_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((PamVMCTrkDig*) G__getstructoffset())->SetRandomExt((TRandom3*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_830_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((PamVMCTrkDig*) G__getstructoffset())->RegisterTrkData((pGPSSPEHits*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_830_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) PamVMCTrkDig::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_830_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) PamVMCTrkDig::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_830_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) PamVMCTrkDig::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_830_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      PamVMCTrkDig::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__PamVMC_fcCint_830_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) PamVMCTrkDig::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_830_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) PamVMCTrkDig::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_830_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) PamVMCTrkDig::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_830_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) PamVMCTrkDig::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef PamVMCTrkDig G__TPamVMCTrkDig;
static int G__PamVMC_fcCint_830_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (PamVMCTrkDig*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((PamVMCTrkDig*) (soff+(sizeof(PamVMCTrkDig)*i)))->~G__TPamVMCTrkDig();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (PamVMCTrkDig*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((PamVMCTrkDig*) (soff))->~G__TPamVMCTrkDig();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


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

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

static int G__PamVMC_fcCint_831_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) PamVMCTofDig::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_831_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) PamVMCTofDig::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_831_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) PamVMCTofDig::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_831_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      PamVMCTofDig::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__PamVMC_fcCint_831_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) PamVMCTofDig::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_831_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) PamVMCTofDig::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_831_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) PamVMCTofDig::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_831_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) PamVMCTofDig::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef PamVMCTofDig G__TPamVMCTofDig;
static int G__PamVMC_fcCint_831_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (PamVMCTofDig*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((PamVMCTofDig*) (soff+(sizeof(PamVMCTofDig)*i)))->~G__TPamVMCTofDig();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (PamVMCTofDig*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((PamVMCTofDig*) (soff))->~G__TPamVMCTofDig();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


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

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

static int G__PamVMC_fcCint_845_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) PamVMCAcDig::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_845_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) PamVMCAcDig::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_845_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) PamVMCAcDig::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_845_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      PamVMCAcDig::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__PamVMC_fcCint_845_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) PamVMCAcDig::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_845_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) PamVMCAcDig::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_845_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) PamVMCAcDig::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_845_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) PamVMCAcDig::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef PamVMCAcDig G__TPamVMCAcDig;
static int G__PamVMC_fcCint_845_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (PamVMCAcDig*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((PamVMCAcDig*) (soff+(sizeof(PamVMCAcDig)*i)))->~G__TPamVMCAcDig();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (PamVMCAcDig*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((PamVMCAcDig*) (soff))->~G__TPamVMCAcDig();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


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

static int G__PamVMC_fcCint_846_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) PamVMCCaloDig::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_846_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) PamVMCCaloDig::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_846_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) PamVMCCaloDig::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_846_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      PamVMCCaloDig::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__PamVMC_fcCint_846_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) PamVMCCaloDig::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_846_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) PamVMCCaloDig::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_846_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) PamVMCCaloDig::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_846_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) PamVMCCaloDig::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef PamVMCCaloDig G__TPamVMCCaloDig;
static int G__PamVMC_fcCint_846_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (PamVMCCaloDig*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((PamVMCCaloDig*) (soff+(sizeof(PamVMCCaloDig)*i)))->~G__TPamVMCCaloDig();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (PamVMCCaloDig*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((PamVMCCaloDig*) (soff))->~G__TPamVMCCaloDig();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


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

static int G__PamVMC_fcCint_847_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) PamVMCS4Dig::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_847_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) PamVMCS4Dig::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_847_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) PamVMCS4Dig::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_847_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      PamVMCS4Dig::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__PamVMC_fcCint_847_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) PamVMCS4Dig::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_847_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) PamVMCS4Dig::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_847_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) PamVMCS4Dig::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_847_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) PamVMCS4Dig::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef PamVMCS4Dig G__TPamVMCS4Dig;
static int G__PamVMC_fcCint_847_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (PamVMCS4Dig*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((PamVMCS4Dig*) (soff+(sizeof(PamVMCS4Dig)*i)))->~G__TPamVMCS4Dig();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (PamVMCS4Dig*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((PamVMCS4Dig*) (soff))->~G__TPamVMCS4Dig();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


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

static int G__PamVMC_fcCint_852_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) PamVMCNDDig::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_852_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) PamVMCNDDig::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_852_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) PamVMCNDDig::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_852_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      PamVMCNDDig::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__PamVMC_fcCint_852_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) PamVMCNDDig::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_852_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) PamVMCNDDig::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_852_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) PamVMCNDDig::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_852_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) PamVMCNDDig::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef PamVMCNDDig G__TPamVMCNDDig;
static int G__PamVMC_fcCint_852_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (PamVMCNDDig*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((PamVMCNDDig*) (soff+(sizeof(PamVMCNDDig)*i)))->~G__TPamVMCNDDig();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (PamVMCNDDig*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((PamVMCNDDig*) (soff))->~G__TPamVMCNDDig();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


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

static int G__PamVMC_fcCint_854_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   PamVMCParticle* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 14
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new PamVMCParticle(
(Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]), (Int_t) G__int(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]));
   } else {
     p = new((void*) gvp) PamVMCParticle(
(Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]), (Int_t) G__int(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]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__PamVMC_fcCintLN_PamVMCParticle));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_854_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) PamVMCParticle::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_854_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) PamVMCParticle::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_854_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) PamVMCParticle::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_854_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      PamVMCParticle::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__PamVMC_fcCint_854_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) PamVMCParticle::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_854_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) PamVMCParticle::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_854_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) PamVMCParticle::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_854_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) PamVMCParticle::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__PamVMC_fcCint_854_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   PamVMCParticle* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new PamVMCParticle(*(PamVMCParticle*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__PamVMC_fcCintLN_PamVMCParticle));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef PamVMCParticle G__TPamVMCParticle;
static int G__PamVMC_fcCint_854_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (PamVMCParticle*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((PamVMCParticle*) (soff+(sizeof(PamVMCParticle)*i)))->~G__TPamVMCParticle();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (PamVMCParticle*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((PamVMCParticle*) (soff))->~G__TPamVMCParticle();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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


/* PamVMCStack */
static int G__PamVMC_fcCint_884_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   PamVMCStack* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new PamVMCStack((Int_t) G__int(libp->para[0]));
   } else {
     p = new((void*) gvp) PamVMCStack((Int_t) G__int(libp->para[0]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__PamVMC_fcCintLN_PamVMCStack));
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

static int G__PamVMC_fcCint_884_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) PamVMCStack::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_884_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) PamVMCStack::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_884_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) PamVMCStack::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_884_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      PamVMCStack::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__PamVMC_fcCint_884_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) PamVMCStack::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_884_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) PamVMCStack::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_884_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) PamVMCStack::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_884_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) PamVMCStack::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__PamVMC_fcCint_884_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   PamVMCStack* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new PamVMCStack(*(PamVMCStack*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__PamVMC_fcCintLN_PamVMCStack));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef PamVMCStack G__TPamVMCStack;
static int G__PamVMC_fcCint_884_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (PamVMCStack*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((PamVMCStack*) (soff+(sizeof(PamVMCStack)*i)))->~G__TPamVMCStack();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (PamVMCStack*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((PamVMCStack*) (soff))->~G__TPamVMCStack();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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


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

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

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

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

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

static int G__PamVMC_fcCint_891_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((PamVMCDetectorSD*) G__getstructoffset())->UpdateHit((TVirtualMC*) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

static int G__PamVMC_fcCint_891_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((PamVMCDetectorSD*) G__getstructoffset())->CreateHit());
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

static int G__PamVMC_fcCint_891_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((PamVMCDetectorSD*) G__getstructoffset())->FillHit((fin) G__int(libp->para[0]), (TVirtualMC*) G__int(libp->para[1])
, (Bool_t) G__int(libp->para[2]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__PamVMC_fcCint_891_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) PamVMCDetectorSD::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_891_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) PamVMCDetectorSD::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_891_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) PamVMCDetectorSD::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_891_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      PamVMCDetectorSD::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__PamVMC_fcCint_891_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) PamVMCDetectorSD::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_891_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) PamVMCDetectorSD::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_891_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) PamVMCDetectorSD::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_891_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) PamVMCDetectorSD::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef PamVMCDetectorSD G__TPamVMCDetectorSD;
static int G__PamVMC_fcCint_891_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (PamVMCDetectorSD*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((PamVMCDetectorSD*) (soff+(sizeof(PamVMCDetectorSD)*i)))->~G__TPamVMCDetectorSD();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (PamVMCDetectorSD*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((PamVMCDetectorSD*) (soff))->~G__TPamVMCDetectorSD();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


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

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

static int G__PamVMC_fcCint_1067_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) PamVMCPrimary::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_1067_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) PamVMCPrimary::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_1067_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) PamVMCPrimary::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_1067_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      PamVMCPrimary::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__PamVMC_fcCint_1067_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) PamVMCPrimary::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_1067_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) PamVMCPrimary::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_1067_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) PamVMCPrimary::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_1067_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) PamVMCPrimary::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__PamVMC_fcCint_1067_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   PamVMCPrimary* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new PamVMCPrimary(*(PamVMCPrimary*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__PamVMC_fcCintLN_PamVMCPrimary));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef PamVMCPrimary G__TPamVMCPrimary;
static int G__PamVMC_fcCint_1067_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (PamVMCPrimary*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((PamVMCPrimary*) (soff+(sizeof(PamVMCPrimary)*i)))->~G__TPamVMCPrimary();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (PamVMCPrimary*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((PamVMCPrimary*) (soff))->~G__TPamVMCPrimary();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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


/* PamVMCPrimaryGenerator */
static int G__PamVMC_fcCint_1068_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   PamVMCPrimaryGenerator* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new PamVMCPrimaryGenerator((TVirtualMCStack*) G__int(libp->para[0]));
   } else {
     p = new((void*) gvp) PamVMCPrimaryGenerator((TVirtualMCStack*) G__int(libp->para[0]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__PamVMC_fcCintLN_PamVMCPrimaryGenerator));
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

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

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

static int G__PamVMC_fcCint_1068_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((PamVMCPrimaryGenerator*) G__getstructoffset())->GenPosition((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_1068_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((PamVMCPrimaryGenerator*) G__getstructoffset())->GenDirection((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_1068_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((PamVMCPrimaryGenerator*) G__getstructoffset())->GenPosAng(*(TVector3*) libp->para[0].ref, *(TVector2*) libp->para[1].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

static int G__PamVMC_fcCint_1068_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 4:
      ((PamVMCPrimaryGenerator*) G__getstructoffset())->GenSpe((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Bool_t) G__int(libp->para[3]));
      G__setnull(result7);
      break;
   case 3:
      ((PamVMCPrimaryGenerator*) G__getstructoffset())->GenSpe((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_1068_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 4:
      ((PamVMCPrimaryGenerator*) G__getstructoffset())->GenSpe_Flat((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Bool_t) G__int(libp->para[3]));
      G__setnull(result7);
      break;
   case 3:
      ((PamVMCPrimaryGenerator*) G__getstructoffset())->GenSpe_Flat((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_1068_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((PamVMCPrimaryGenerator*) G__getstructoffset())->GenSpe_3par((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__PamVMC_fcCint_1068_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((PamVMCPrimaryGenerator*) G__getstructoffset())->GenSphPhiThe((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_1068_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((PamVMCPrimaryGenerator*) G__getstructoffset())->GetParticleID());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_1068_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((PamVMCPrimaryGenerator*) G__getstructoffset())->GetParticle());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_1068_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((PamVMCPrimaryGenerator*) G__getstructoffset())->GetPositon(*(TVector3*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_1068_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((PamVMCPrimaryGenerator*) G__getstructoffset())->GetPosition(*(Double_t*) G__Doubleref(&libp->para[0]), *(Double_t*) G__Doubleref(&libp->para[1])
, *(Double_t*) G__Doubleref(&libp->para[2]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_1068_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((PamVMCPrimaryGenerator*) G__getstructoffset())->GetKinEnergy());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_1068_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((PamVMCPrimaryGenerator*) G__getstructoffset())->GetRigidity());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_1068_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((PamVMCPrimaryGenerator*) G__getstructoffset())->GetMomentum());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_1068_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((PamVMCPrimaryGenerator*) G__getstructoffset())->Get2PiArea());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_1068_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((PamVMCPrimaryGenerator*) G__getstructoffset())->GetDirection(*(TVector2*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_1068_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((PamVMCPrimaryGenerator*) G__getstructoffset())->GetDirection(*(Double_t*) G__Doubleref(&libp->para[0]), *(Double_t*) G__Doubleref(&libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__PamVMC_fcCint_1068_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((PamVMCPrimaryGenerator*) G__getstructoffset())->GetTol(*(Double_t*) G__Doubleref(&libp->para[0]), *(Double_t*) G__Doubleref(&libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_1068_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((PamVMCPrimaryGenerator*) G__getstructoffset())->GetCR_GF(*(Double_t*) G__Doubleref(&libp->para[0]), *(Double_t*) G__Doubleref(&libp->para[1])
, (Int_t) G__int(libp->para[2]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_1068_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((PamVMCPrimaryGenerator*) G__getstructoffset())->GetNgood());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_1068_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((PamVMCPrimaryGenerator*) G__getstructoffset())->SetRandom((TRandom*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

static int G__PamVMC_fcCint_1068_0_44(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((PamVMCPrimaryGenerator*) G__getstructoffset())->MomentumToKinE((Double_t) G__double(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_1068_0_45(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((PamVMCPrimaryGenerator*) G__getstructoffset())->KinEToMomentum((Double_t) G__double(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_1068_0_46(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((PamVMCPrimaryGenerator*) G__getstructoffset())->MomentumToRig((Double_t) G__double(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_1068_0_47(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((PamVMCPrimaryGenerator*) G__getstructoffset())->RigToMomentum((Double_t) G__double(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_1068_0_48(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((PamVMCPrimaryGenerator*) G__getstructoffset())->function3par((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__PamVMC_fcCint_1068_0_49(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) PamVMCPrimaryGenerator::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_1068_0_50(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) PamVMCPrimaryGenerator::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_1068_0_51(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) PamVMCPrimaryGenerator::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_1068_0_52(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      PamVMCPrimaryGenerator::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__PamVMC_fcCint_1068_0_57(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) PamVMCPrimaryGenerator::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_1068_0_58(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) PamVMCPrimaryGenerator::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_1068_0_59(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) PamVMCPrimaryGenerator::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_1068_0_60(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) PamVMCPrimaryGenerator::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__PamVMC_fcCint_1068_0_61(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   PamVMCPrimaryGenerator* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new PamVMCPrimaryGenerator(*(PamVMCPrimaryGenerator*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__PamVMC_fcCintLN_PamVMCPrimaryGenerator));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef PamVMCPrimaryGenerator G__TPamVMCPrimaryGenerator;
static int G__PamVMC_fcCint_1068_0_62(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (PamVMCPrimaryGenerator*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((PamVMCPrimaryGenerator*) (soff+(sizeof(PamVMCPrimaryGenerator)*i)))->~G__TPamVMCPrimaryGenerator();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (PamVMCPrimaryGenerator*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((PamVMCPrimaryGenerator*) (soff))->~G__TPamVMCPrimaryGenerator();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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


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

static int G__PamVMC_fcCint_1163_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   pCutControl* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 23
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new pCutControl(
(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]), (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])
, (Double_t) G__double(libp->para[14]), (Double_t) G__double(libp->para[15])
, (Double_t) G__double(libp->para[16]), (Double_t) G__double(libp->para[17])
, (Double_t) G__double(libp->para[18]), (Double_t) G__double(libp->para[19])
, (Double_t) G__double(libp->para[20]), (Double_t) G__double(libp->para[21])
, (Double_t) G__double(libp->para[22]));
   } else {
     p = new((void*) gvp) pCutControl(
(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]), (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])
, (Double_t) G__double(libp->para[14]), (Double_t) G__double(libp->para[15])
, (Double_t) G__double(libp->para[16]), (Double_t) G__double(libp->para[17])
, (Double_t) G__double(libp->para[18]), (Double_t) G__double(libp->para[19])
, (Double_t) G__double(libp->para[20]), (Double_t) G__double(libp->para[21])
, (Double_t) G__double(libp->para[22]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__PamVMC_fcCintLN_pCutControl));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_1163_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((pCutControl*) G__getstructoffset())->GetID());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_1163_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((pCutControl*) G__getstructoffset())->GetCUTGAM());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_1163_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((pCutControl*) G__getstructoffset())->GetBCUTE());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_1163_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((pCutControl*) G__getstructoffset())->GetCUTELE());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_1163_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((pCutControl*) G__getstructoffset())->GetDCUTE());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_1163_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((pCutControl*) G__getstructoffset())->GetCUTNEU());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_1163_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((pCutControl*) G__getstructoffset())->GetCUTHAD());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_1163_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((pCutControl*) G__getstructoffset())->GetCUTMUO());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_1163_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((pCutControl*) G__getstructoffset())->GetDCUTM());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_1163_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((pCutControl*) G__getstructoffset())->GetBCUTM());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_1163_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((pCutControl*) G__getstructoffset())->GetPPCUTM());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_1163_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((pCutControl*) G__getstructoffset())->GetPAIR());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_1163_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((pCutControl*) G__getstructoffset())->GetCOMP());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_1163_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((pCutControl*) G__getstructoffset())->GetPHOT());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_1163_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((pCutControl*) G__getstructoffset())->GetPFIS());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_1163_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((pCutControl*) G__getstructoffset())->GetDRAY());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_1163_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((pCutControl*) G__getstructoffset())->GetANNI());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_1163_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((pCutControl*) G__getstructoffset())->GetBREM());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_1163_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((pCutControl*) G__getstructoffset())->GetHADR());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_1163_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((pCutControl*) G__getstructoffset())->GetMUNU());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_1163_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((pCutControl*) G__getstructoffset())->GetDCAY());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_1163_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((pCutControl*) G__getstructoffset())->GetLOSS());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_1163_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((pCutControl*) G__getstructoffset())->GetMULS());
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

static int G__PamVMC_fcCint_1163_0_49(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((pCutControl*) G__getstructoffset())->FindMedia());
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__PamVMC_fcCint_1163_0_52(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) pCutControl::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_1163_0_53(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) pCutControl::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_1163_0_54(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) pCutControl::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_1163_0_55(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      pCutControl::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__PamVMC_fcCint_1163_0_60(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) pCutControl::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_1163_0_61(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) pCutControl::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_1163_0_62(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) pCutControl::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_1163_0_63(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) pCutControl::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__PamVMC_fcCint_1163_0_64(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   pCutControl* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new pCutControl(*(pCutControl*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__PamVMC_fcCintLN_pCutControl));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef pCutControl G__TpCutControl;
static int G__PamVMC_fcCint_1163_0_65(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (pCutControl*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((pCutControl*) (soff+(sizeof(pCutControl)*i)))->~G__TpCutControl();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (pCutControl*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((pCutControl*) (soff))->~G__TpCutControl();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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


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

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

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

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

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

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

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

static int G__PamVMC_fcCint_1170_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((PamVMCDetGeom*) G__getstructoffset())->AddMotherProp((pMotherProp*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_1170_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((PamVMCDetGeom*) G__getstructoffset())->AddMotherProp((TObjArray*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_1170_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((PamVMCDetGeom*) G__getstructoffset())->SetMotherProp((pMotherProp*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_1170_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((PamVMCDetGeom*) G__getstructoffset())->SetMotherProp((TGeoVolume*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (TGeoMatrix*) G__int(libp->para[2]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_1170_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((PamVMCDetGeom*) G__getstructoffset())->SetMotherVol((TGeoVolume*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_1170_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((PamVMCDetGeom*) G__getstructoffset())->GetMotherProp());
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__PamVMC_fcCint_1170_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((PamVMCDetGeom*) G__getstructoffset())->RegisterNodes((TObjArray*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_1170_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) PamVMCDetGeom::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_1170_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) PamVMCDetGeom::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_1170_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) PamVMCDetGeom::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_1170_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      PamVMCDetGeom::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__PamVMC_fcCint_1170_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) PamVMCDetGeom::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_1170_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) PamVMCDetGeom::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_1170_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) PamVMCDetGeom::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_1170_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) PamVMCDetGeom::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef PamVMCDetGeom G__TPamVMCDetGeom;
static int G__PamVMC_fcCint_1170_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (PamVMCDetGeom*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((PamVMCDetGeom*) (soff+(sizeof(PamVMCDetGeom)*i)))->~G__TPamVMCDetGeom();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (PamVMCDetGeom*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((PamVMCDetGeom*) (soff))->~G__TPamVMCDetGeom();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* PamVMCDetector */
static int G__PamVMC_fcCint_1173_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((PamVMCDetector*) G__getstructoffset())->DefineGeometry();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

static int G__PamVMC_fcCint_1173_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((PamVMCDetector*) G__getstructoffset())->GetMotherVol());
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

static int G__PamVMC_fcCint_1173_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((PamVMCDetector*) G__getstructoffset())->AddMotherProp((TObjArray*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__PamVMC_fcCint_1173_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((PamVMCDetector*) G__getstructoffset())->SetMotherProp((TGeoVolume*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (TGeoMatrix*) G__int(libp->para[2]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

static int G__PamVMC_fcCint_1173_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((PamVMCDetector*) G__getstructoffset())->GetMotherProp());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_1173_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((PamVMCDetector*) G__getstructoffset())->SetMotherVol((TGeoVolume*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

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

static int G__PamVMC_fcCint_1173_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) PamVMCDetector::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_1173_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) PamVMCDetector::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_1173_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) PamVMCDetector::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_1173_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      PamVMCDetector::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__PamVMC_fcCint_1173_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) PamVMCDetector::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_1173_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) PamVMCDetector::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_1173_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) PamVMCDetector::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_1173_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) PamVMCDetector::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef PamVMCDetector G__TPamVMCDetector;
static int G__PamVMC_fcCint_1173_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (PamVMCDetector*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((PamVMCDetector*) (soff+(sizeof(PamVMCDetector)*i)))->~G__TPamVMCDetector();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (PamVMCDetector*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((PamVMCDetector*) (soff))->~G__TPamVMCDetector();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


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

static int G__PamVMC_fcCint_1174_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((PamVMCCaloSD*) G__getstructoffset())->GetPlaneID());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_1174_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((PamVMCCaloSD*) G__getstructoffset())->GetViewID());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_1174_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((PamVMCCaloSD*) G__getstructoffset())->GetStripID());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_1174_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) PamVMCCaloSD::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_1174_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) PamVMCCaloSD::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_1174_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) PamVMCCaloSD::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_1174_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      PamVMCCaloSD::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__PamVMC_fcCint_1174_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) PamVMCCaloSD::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_1174_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) PamVMCCaloSD::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_1174_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) PamVMCCaloSD::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_1174_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) PamVMCCaloSD::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef PamVMCCaloSD G__TPamVMCCaloSD;
static int G__PamVMC_fcCint_1174_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (PamVMCCaloSD*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((PamVMCCaloSD*) (soff+(sizeof(PamVMCCaloSD)*i)))->~G__TPamVMCCaloSD();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (PamVMCCaloSD*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((PamVMCCaloSD*) (soff))->~G__TPamVMCCaloSD();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


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

static int G__PamVMC_fcCint_1175_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) PamVMCDetCalo::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_1175_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) PamVMCDetCalo::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_1175_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) PamVMCDetCalo::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_1175_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      PamVMCDetCalo::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__PamVMC_fcCint_1175_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) PamVMCDetCalo::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_1175_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) PamVMCDetCalo::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_1175_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) PamVMCDetCalo::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_1175_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) PamVMCDetCalo::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef PamVMCDetCalo G__TPamVMCDetCalo;
static int G__PamVMC_fcCint_1175_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (PamVMCDetCalo*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((PamVMCDetCalo*) (soff+(sizeof(PamVMCDetCalo)*i)))->~G__TPamVMCDetCalo();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (PamVMCDetCalo*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((PamVMCDetCalo*) (soff))->~G__TPamVMCDetCalo();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


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

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

static int G__PamVMC_fcCint_1184_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) pTrkHitData::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_1184_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) pTrkHitData::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_1184_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) pTrkHitData::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_1184_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      pTrkHitData::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__PamVMC_fcCint_1184_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) pTrkHitData::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_1184_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) pTrkHitData::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_1184_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) pTrkHitData::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_1184_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) pTrkHitData::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__PamVMC_fcCint_1184_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   pTrkHitData* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new pTrkHitData(*(pTrkHitData*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__PamVMC_fcCintLN_pTrkHitData));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef pTrkHitData G__TpTrkHitData;
static int G__PamVMC_fcCint_1184_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (pTrkHitData*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((pTrkHitData*) (soff+(sizeof(pTrkHitData)*i)))->~G__TpTrkHitData();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (pTrkHitData*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((pTrkHitData*) (soff))->~G__TpTrkHitData();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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


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

static int G__PamVMC_fcCint_1185_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((PamVMCTrkHit*) G__getstructoffset())->GenTrkHit());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_1185_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((PamVMCTrkHit*) G__getstructoffset())->operator=(*(PamVMCTrkHit*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

static int G__PamVMC_fcCint_1185_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((PamVMCTrkHit*) G__getstructoffset())->SetXAVESPE((Float_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_1185_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((PamVMCTrkHit*) G__getstructoffset())->SetYAVESPE((Float_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_1185_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((PamVMCTrkHit*) G__getstructoffset())->SetZAVESPE((Float_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_1185_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((PamVMCTrkHit*) G__getstructoffset())->GetTrkHit());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_1185_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((PamVMCTrkHit*) G__getstructoffset())->GetNXMULT());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_1185_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((PamVMCTrkHit*) G__getstructoffset())->GetNYMULT());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_1185_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((PamVMCTrkHit*) G__getstructoffset())->GetXAVESPE());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_1185_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((PamVMCTrkHit*) G__getstructoffset())->GetYAVESPE());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_1185_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((PamVMCTrkHit*) G__getstructoffset())->GetZAVESPE());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_1185_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) PamVMCTrkHit::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_1185_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) PamVMCTrkHit::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_1185_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) PamVMCTrkHit::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_1185_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      PamVMCTrkHit::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__PamVMC_fcCint_1185_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) PamVMCTrkHit::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_1185_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) PamVMCTrkHit::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_1185_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) PamVMCTrkHit::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_1185_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) PamVMCTrkHit::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__PamVMC_fcCint_1185_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   PamVMCTrkHit* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new PamVMCTrkHit(*(PamVMCTrkHit*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__PamVMC_fcCintLN_PamVMCTrkHit));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef PamVMCTrkHit G__TPamVMCTrkHit;
static int G__PamVMC_fcCint_1185_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (PamVMCTrkHit*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((PamVMCTrkHit*) (soff+(sizeof(PamVMCTrkHit)*i)))->~G__TPamVMCTrkHit();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (PamVMCTrkHit*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((PamVMCTrkHit*) (soff))->~G__TPamVMCTrkHit();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


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

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

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

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

static int G__PamVMC_fcCint_1188_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((PamVMCTrkSD*) G__getstructoffset())->CreateTrkHit());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_1188_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((PamVMCTrkSD*) G__getstructoffset())->SetTrkHit((PamVMCTrkHit*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__PamVMC_fcCint_1188_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((PamVMCTrkSD*) G__getstructoffset())->GetPlaneID());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_1188_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((PamVMCTrkSD*) G__getstructoffset())->GetPadID());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_1188_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) PamVMCTrkSD::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_1188_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) PamVMCTrkSD::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_1188_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) PamVMCTrkSD::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_1188_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      PamVMCTrkSD::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__PamVMC_fcCint_1188_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) PamVMCTrkSD::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_1188_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) PamVMCTrkSD::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_1188_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) PamVMCTrkSD::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_1188_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) PamVMCTrkSD::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef PamVMCTrkSD G__TPamVMCTrkSD;
static int G__PamVMC_fcCint_1188_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (PamVMCTrkSD*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((PamVMCTrkSD*) (soff+(sizeof(PamVMCTrkSD)*i)))->~G__TPamVMCTrkSD();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (PamVMCTrkSD*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((PamVMCTrkSD*) (soff))->~G__TPamVMCTrkSD();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


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

static int G__PamVMC_fcCint_1189_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) PamVMCDetTrk::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_1189_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) PamVMCDetTrk::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_1189_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) PamVMCDetTrk::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_1189_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      PamVMCDetTrk::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__PamVMC_fcCint_1189_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) PamVMCDetTrk::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_1189_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) PamVMCDetTrk::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_1189_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) PamVMCDetTrk::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_1189_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) PamVMCDetTrk::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef PamVMCDetTrk G__TPamVMCDetTrk;
static int G__PamVMC_fcCint_1189_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (PamVMCDetTrk*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((PamVMCDetTrk*) (soff+(sizeof(PamVMCDetTrk)*i)))->~G__TPamVMCDetTrk();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (PamVMCDetTrk*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((PamVMCDetTrk*) (soff))->~G__TPamVMCDetTrk();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* PamVMCTofSD */
static int G__PamVMC_fcCint_1190_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   PamVMCTofSD* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new PamVMCTofSD((const char*) G__int(libp->para[0]));
   } else {
     p = new((void*) gvp) PamVMCTofSD((const char*) G__int(libp->para[0]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__PamVMC_fcCintLN_PamVMCTofSD));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_1190_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) PamVMCTofSD::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_1190_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) PamVMCTofSD::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_1190_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) PamVMCTofSD::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_1190_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      PamVMCTofSD::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__PamVMC_fcCint_1190_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) PamVMCTofSD::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_1190_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) PamVMCTofSD::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_1190_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) PamVMCTofSD::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_1190_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) PamVMCTofSD::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef PamVMCTofSD G__TPamVMCTofSD;
static int G__PamVMC_fcCint_1190_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (PamVMCTofSD*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((PamVMCTofSD*) (soff+(sizeof(PamVMCTofSD)*i)))->~G__TPamVMCTofSD();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (PamVMCTofSD*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((PamVMCTofSD*) (soff))->~G__TPamVMCTofSD();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


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

static int G__PamVMC_fcCint_1191_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) PamVMCDetTofS1::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_1191_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) PamVMCDetTofS1::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_1191_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) PamVMCDetTofS1::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_1191_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      PamVMCDetTofS1::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__PamVMC_fcCint_1191_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) PamVMCDetTofS1::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_1191_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) PamVMCDetTofS1::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_1191_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) PamVMCDetTofS1::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_1191_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) PamVMCDetTofS1::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef PamVMCDetTofS1 G__TPamVMCDetTofS1;
static int G__PamVMC_fcCint_1191_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (PamVMCDetTofS1*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((PamVMCDetTofS1*) (soff+(sizeof(PamVMCDetTofS1)*i)))->~G__TPamVMCDetTofS1();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (PamVMCDetTofS1*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((PamVMCDetTofS1*) (soff))->~G__TPamVMCDetTofS1();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


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

static int G__PamVMC_fcCint_1192_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) PamVMCDetTofS2::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_1192_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) PamVMCDetTofS2::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_1192_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) PamVMCDetTofS2::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_1192_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      PamVMCDetTofS2::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__PamVMC_fcCint_1192_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) PamVMCDetTofS2::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_1192_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) PamVMCDetTofS2::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_1192_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) PamVMCDetTofS2::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_1192_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) PamVMCDetTofS2::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef PamVMCDetTofS2 G__TPamVMCDetTofS2;
static int G__PamVMC_fcCint_1192_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (PamVMCDetTofS2*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((PamVMCDetTofS2*) (soff+(sizeof(PamVMCDetTofS2)*i)))->~G__TPamVMCDetTofS2();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (PamVMCDetTofS2*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((PamVMCDetTofS2*) (soff))->~G__TPamVMCDetTofS2();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


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

static int G__PamVMC_fcCint_1193_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) PamVMCDetTofS3::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_1193_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) PamVMCDetTofS3::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_1193_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) PamVMCDetTofS3::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_1193_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      PamVMCDetTofS3::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__PamVMC_fcCint_1193_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) PamVMCDetTofS3::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_1193_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) PamVMCDetTofS3::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_1193_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) PamVMCDetTofS3::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_1193_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) PamVMCDetTofS3::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef PamVMCDetTofS3 G__TPamVMCDetTofS3;
static int G__PamVMC_fcCint_1193_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (PamVMCDetTofS3*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((PamVMCDetTofS3*) (soff+(sizeof(PamVMCDetTofS3)*i)))->~G__TPamVMCDetTofS3();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (PamVMCDetTofS3*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((PamVMCDetTofS3*) (soff))->~G__TPamVMCDetTofS3();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


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

static int G__PamVMC_fcCint_1194_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) PamVMCDetTof::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_1194_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) PamVMCDetTof::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_1194_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) PamVMCDetTof::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_1194_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      PamVMCDetTof::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__PamVMC_fcCint_1194_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) PamVMCDetTof::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_1194_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) PamVMCDetTof::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_1194_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) PamVMCDetTof::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_1194_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) PamVMCDetTof::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef PamVMCDetTof G__TPamVMCDetTof;
static int G__PamVMC_fcCint_1194_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (PamVMCDetTof*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((PamVMCDetTof*) (soff+(sizeof(PamVMCDetTof)*i)))->~G__TPamVMCDetTof();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (PamVMCDetTof*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((PamVMCDetTof*) (soff))->~G__TPamVMCDetTof();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* PamVMCCardSD */
static int G__PamVMC_fcCint_1195_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   PamVMCCardSD* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new PamVMCCardSD((const char*) G__int(libp->para[0]));
   } else {
     p = new((void*) gvp) PamVMCCardSD((const char*) G__int(libp->para[0]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__PamVMC_fcCintLN_PamVMCCardSD));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_1195_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) PamVMCCardSD::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_1195_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) PamVMCCardSD::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_1195_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) PamVMCCardSD::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_1195_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      PamVMCCardSD::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__PamVMC_fcCint_1195_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) PamVMCCardSD::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_1195_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) PamVMCCardSD::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_1195_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) PamVMCCardSD::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_1195_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) PamVMCCardSD::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef PamVMCCardSD G__TPamVMCCardSD;
static int G__PamVMC_fcCint_1195_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (PamVMCCardSD*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((PamVMCCardSD*) (soff+(sizeof(PamVMCCardSD)*i)))->~G__TPamVMCCardSD();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (PamVMCCardSD*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((PamVMCCardSD*) (soff))->~G__TPamVMCCardSD();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


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

static int G__PamVMC_fcCint_1196_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) PamVMCDetCard::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_1196_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) PamVMCDetCard::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_1196_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) PamVMCDetCard::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_1196_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      PamVMCDetCard::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__PamVMC_fcCint_1196_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) PamVMCDetCard::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_1196_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) PamVMCDetCard::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_1196_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) PamVMCDetCard::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_1196_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) PamVMCDetCard::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef PamVMCDetCard G__TPamVMCDetCard;
static int G__PamVMC_fcCint_1196_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (PamVMCDetCard*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((PamVMCDetCard*) (soff+(sizeof(PamVMCDetCard)*i)))->~G__TPamVMCDetCard();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (PamVMCDetCard*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((PamVMCDetCard*) (soff))->~G__TPamVMCDetCard();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


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

static int G__PamVMC_fcCint_1197_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) PamVMCCasSD::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_1197_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) PamVMCCasSD::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_1197_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) PamVMCCasSD::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_1197_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      PamVMCCasSD::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__PamVMC_fcCint_1197_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) PamVMCCasSD::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_1197_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) PamVMCCasSD::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_1197_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) PamVMCCasSD::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_1197_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) PamVMCCasSD::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef PamVMCCasSD G__TPamVMCCasSD;
static int G__PamVMC_fcCint_1197_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (PamVMCCasSD*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((PamVMCCasSD*) (soff+(sizeof(PamVMCCasSD)*i)))->~G__TPamVMCCasSD();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (PamVMCCasSD*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((PamVMCCasSD*) (soff))->~G__TPamVMCCasSD();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


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

static int G__PamVMC_fcCint_1198_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) PamVMCDetCas::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_1198_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) PamVMCDetCas::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_1198_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) PamVMCDetCas::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_1198_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      PamVMCDetCas::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__PamVMC_fcCint_1198_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) PamVMCDetCas::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_1198_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) PamVMCDetCas::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_1198_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) PamVMCDetCas::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_1198_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) PamVMCDetCas::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef PamVMCDetCas G__TPamVMCDetCas;
static int G__PamVMC_fcCint_1198_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (PamVMCDetCas*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((PamVMCDetCas*) (soff+(sizeof(PamVMCDetCas)*i)))->~G__TPamVMCDetCas();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (PamVMCDetCas*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((PamVMCDetCas*) (soff))->~G__TPamVMCDetCas();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


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

static int G__PamVMC_fcCint_1199_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) PamVMCCatSD::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_1199_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) PamVMCCatSD::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_1199_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) PamVMCCatSD::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_1199_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      PamVMCCatSD::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__PamVMC_fcCint_1199_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) PamVMCCatSD::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_1199_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) PamVMCCatSD::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_1199_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) PamVMCCatSD::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_1199_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) PamVMCCatSD::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef PamVMCCatSD G__TPamVMCCatSD;
static int G__PamVMC_fcCint_1199_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (PamVMCCatSD*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((PamVMCCatSD*) (soff+(sizeof(PamVMCCatSD)*i)))->~G__TPamVMCCatSD();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (PamVMCCatSD*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((PamVMCCatSD*) (soff))->~G__TPamVMCCatSD();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


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

static int G__PamVMC_fcCint_1200_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) PamVMCDetCat::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_1200_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) PamVMCDetCat::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_1200_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) PamVMCDetCat::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_1200_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      PamVMCDetCat::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__PamVMC_fcCint_1200_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) PamVMCDetCat::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_1200_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) PamVMCDetCat::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_1200_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) PamVMCDetCat::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_1200_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) PamVMCDetCat::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef PamVMCDetCat G__TPamVMCDetCat;
static int G__PamVMC_fcCint_1200_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (PamVMCDetCat*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((PamVMCDetCat*) (soff+(sizeof(PamVMCDetCat)*i)))->~G__TPamVMCDetCat();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (PamVMCDetCat*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((PamVMCDetCat*) (soff))->~G__TPamVMCDetCat();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


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

static int G__PamVMC_fcCint_1201_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) PamVMCDetAc::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_1201_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) PamVMCDetAc::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_1201_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) PamVMCDetAc::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_1201_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      PamVMCDetAc::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__PamVMC_fcCint_1201_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) PamVMCDetAc::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_1201_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) PamVMCDetAc::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_1201_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) PamVMCDetAc::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_1201_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) PamVMCDetAc::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef PamVMCDetAc G__TPamVMCDetAc;
static int G__PamVMC_fcCint_1201_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (PamVMCDetAc*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((PamVMCDetAc*) (soff+(sizeof(PamVMCDetAc)*i)))->~G__TPamVMCDetAc();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (PamVMCDetAc*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((PamVMCDetAc*) (soff))->~G__TPamVMCDetAc();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


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

static int G__PamVMC_fcCint_1202_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) PamVMCS4SD::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_1202_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) PamVMCS4SD::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_1202_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) PamVMCS4SD::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_1202_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      PamVMCS4SD::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__PamVMC_fcCint_1202_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) PamVMCS4SD::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_1202_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) PamVMCS4SD::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_1202_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) PamVMCS4SD::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_1202_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) PamVMCS4SD::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef PamVMCS4SD G__TPamVMCS4SD;
static int G__PamVMC_fcCint_1202_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (PamVMCS4SD*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((PamVMCS4SD*) (soff+(sizeof(PamVMCS4SD)*i)))->~G__TPamVMCS4SD();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (PamVMCS4SD*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((PamVMCS4SD*) (soff))->~G__TPamVMCS4SD();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


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

static int G__PamVMC_fcCint_1203_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) PamVMCDetS4::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_1203_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) PamVMCDetS4::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_1203_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) PamVMCDetS4::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_1203_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      PamVMCDetS4::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__PamVMC_fcCint_1203_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) PamVMCDetS4::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_1203_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) PamVMCDetS4::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_1203_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) PamVMCDetS4::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_1203_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) PamVMCDetS4::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef PamVMCDetS4 G__TPamVMCDetS4;
static int G__PamVMC_fcCint_1203_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (PamVMCDetS4*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((PamVMCDetS4*) (soff+(sizeof(PamVMCDetS4)*i)))->~G__TPamVMCDetS4();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (PamVMCDetS4*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((PamVMCDetS4*) (soff))->~G__TPamVMCDetS4();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


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

static int G__PamVMC_fcCint_1204_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) PamVMCNDSD::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_1204_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) PamVMCNDSD::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_1204_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) PamVMCNDSD::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_1204_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      PamVMCNDSD::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__PamVMC_fcCint_1204_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) PamVMCNDSD::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_1204_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) PamVMCNDSD::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_1204_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) PamVMCNDSD::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_1204_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) PamVMCNDSD::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef PamVMCNDSD G__TPamVMCNDSD;
static int G__PamVMC_fcCint_1204_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (PamVMCNDSD*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((PamVMCNDSD*) (soff+(sizeof(PamVMCNDSD)*i)))->~G__TPamVMCNDSD();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (PamVMCNDSD*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((PamVMCNDSD*) (soff))->~G__TPamVMCNDSD();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


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

static int G__PamVMC_fcCint_1205_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) PamVMCDetND::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_1205_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) PamVMCDetND::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_1205_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) PamVMCDetND::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_1205_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      PamVMCDetND::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__PamVMC_fcCint_1205_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) PamVMCDetND::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_1205_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) PamVMCDetND::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_1205_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) PamVMCDetND::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_1205_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) PamVMCDetND::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef PamVMCDetND G__TPamVMCDetND;
static int G__PamVMC_fcCint_1205_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (PamVMCDetND*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((PamVMCDetND*) (soff+(sizeof(PamVMCDetND)*i)))->~G__TPamVMCDetND();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (PamVMCDetND*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((PamVMCDetND*) (soff))->~G__TPamVMCDetND();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


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

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

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

static int G__PamVMC_fcCint_1206_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) PamVMCDetPamela::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_1206_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) PamVMCDetPamela::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_1206_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) PamVMCDetPamela::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_1206_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      PamVMCDetPamela::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__PamVMC_fcCint_1206_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) PamVMCDetPamela::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_1206_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) PamVMCDetPamela::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_1206_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) PamVMCDetPamela::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_1206_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) PamVMCDetPamela::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef PamVMCDetPamela G__TPamVMCDetPamela;
static int G__PamVMC_fcCint_1206_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (PamVMCDetPamela*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((PamVMCDetPamela*) (soff+(sizeof(PamVMCDetPamela)*i)))->~G__TPamVMCDetPamela();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (PamVMCDetPamela*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((PamVMCDetPamela*) (soff))->~G__TPamVMCDetPamela();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


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

static int G__PamVMC_fcCint_1208_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) PamVMCApplication::Instance());
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__PamVMC_fcCint_1208_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((PamVMCApplication*) G__getstructoffset())->GetTrigger());
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

static int G__PamVMC_fcCint_1208_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) PamVMCApplication::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_1208_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) PamVMCApplication::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_1208_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) PamVMCApplication::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_1208_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      PamVMCApplication::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__PamVMC_fcCint_1208_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) PamVMCApplication::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_1208_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) PamVMCApplication::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_1208_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) PamVMCApplication::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__PamVMC_fcCint_1208_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) PamVMCApplication::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__PamVMC_fcCint_1208_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   PamVMCApplication* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new PamVMCApplication(*(PamVMCApplication*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__PamVMC_fcCintLN_PamVMCApplication));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef PamVMCApplication G__TPamVMCApplication;
static int G__PamVMC_fcCint_1208_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (PamVMCApplication*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((PamVMCApplication*) (soff+(sizeof(PamVMCApplication)*i)))->~G__TPamVMCApplication();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (PamVMCApplication*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((PamVMCApplication*) (soff))->~G__TPamVMCApplication();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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


/* Setting up global function */

/*********************************************************
* Member function Stub
*********************************************************/

/* PamRootManager */

/* pHitData */

/* PamVMCDetectorHit */

/* PamVMCOptMgr */

/* PamVMCDigitizer */

/* GPSSPEData */

/* pGPSSPEHits */

/* PamVMCTrkDig */

/* PamVMCTofDig */

/* PamVMCAcDig */

/* PamVMCCaloDig */

/* PamVMCS4Dig */

/* PamVMCNDDig */

/* PamVMCParticle */

/* PamVMCStack */

/* PamVMCDetectorSD */

/* PamVMCPrimary */

/* PamVMCPrimaryGenerator */

/* pCutControl */

/* PamVMCDetGeom */

/* PamVMCDetector */

/* PamVMCCaloSD */

/* PamVMCDetCalo */

/* pTrkHitData */

/* PamVMCTrkHit */

/* PamVMCTrkSD */

/* PamVMCDetTrk */

/* PamVMCTofSD */

/* PamVMCDetTofS1 */

/* PamVMCDetTofS2 */

/* PamVMCDetTofS3 */

/* PamVMCDetTof */

/* PamVMCCardSD */

/* PamVMCDetCard */

/* PamVMCCasSD */

/* PamVMCDetCas */

/* PamVMCCatSD */

/* PamVMCDetCat */

/* PamVMCDetAc */

/* PamVMCS4SD */

/* PamVMCDetS4 */

/* PamVMCNDSD */

/* PamVMCDetND */

/* PamVMCDetPamela */

/* PamVMCApplication */

/*********************************************************
* Global function Stub
*********************************************************/

/*********************************************************
* Get size of pointer to member function
*********************************************************/
class G__Sizep2memfuncPamVMC_fcCint {
 public:
  G__Sizep2memfuncPamVMC_fcCint(): p(&G__Sizep2memfuncPamVMC_fcCint::sizep2memfunc) {}
    size_t sizep2memfunc() { return(sizeof(p)); }
  private:
    size_t (G__Sizep2memfuncPamVMC_fcCint::*p)();
};

size_t G__get_sizep2memfuncPamVMC_fcCint()
{
  G__Sizep2memfuncPamVMC_fcCint 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_inheritancePamVMC_fcCint() {

   /* Setting up class inheritance */
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__PamVMC_fcCintLN_PamRootManager))) {
     PamRootManager *G__Lderived;
     G__Lderived=(PamRootManager*)0x1000;
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__PamVMC_fcCintLN_PamRootManager),G__get_linked_tagnum(&G__PamVMC_fcCintLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__PamVMC_fcCintLN_pHitData))) {
     pHitData *G__Lderived;
     G__Lderived=(pHitData*)0x1000;
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__PamVMC_fcCintLN_pHitData),G__get_linked_tagnum(&G__PamVMC_fcCintLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__PamVMC_fcCintLN_PamVMCDetectorHit))) {
     PamVMCDetectorHit *G__Lderived;
     G__Lderived=(PamVMCDetectorHit*)0x1000;
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__PamVMC_fcCintLN_PamVMCDetectorHit),G__get_linked_tagnum(&G__PamVMC_fcCintLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__PamVMC_fcCintLN_PamVMCOptMgr))) {
     PamVMCOptMgr *G__Lderived;
     G__Lderived=(PamVMCOptMgr*)0x1000;
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__PamVMC_fcCintLN_PamVMCOptMgr),G__get_linked_tagnum(&G__PamVMC_fcCintLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__PamVMC_fcCintLN_PamVMCDigitizer))) {
     PamVMCDigitizer *G__Lderived;
     G__Lderived=(PamVMCDigitizer*)0x1000;
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__PamVMC_fcCintLN_PamVMCDigitizer),G__get_linked_tagnum(&G__PamVMC_fcCintLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__PamVMC_fcCintLN_GPSSPEData))) {
     GPSSPEData *G__Lderived;
     G__Lderived=(GPSSPEData*)0x1000;
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__PamVMC_fcCintLN_GPSSPEData),G__get_linked_tagnum(&G__PamVMC_fcCintLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__PamVMC_fcCintLN_PamVMCTrkDig))) {
     PamVMCTrkDig *G__Lderived;
     G__Lderived=(PamVMCTrkDig*)0x1000;
     {
       PamVMCDigitizer *G__Lpbase=(PamVMCDigitizer*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__PamVMC_fcCintLN_PamVMCTrkDig),G__get_linked_tagnum(&G__PamVMC_fcCintLN_PamVMCDigitizer),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__PamVMC_fcCintLN_PamVMCTrkDig),G__get_linked_tagnum(&G__PamVMC_fcCintLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__PamVMC_fcCintLN_PamVMCTofDig))) {
     PamVMCTofDig *G__Lderived;
     G__Lderived=(PamVMCTofDig*)0x1000;
     {
       PamVMCDigitizer *G__Lpbase=(PamVMCDigitizer*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__PamVMC_fcCintLN_PamVMCTofDig),G__get_linked_tagnum(&G__PamVMC_fcCintLN_PamVMCDigitizer),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__PamVMC_fcCintLN_PamVMCTofDig),G__get_linked_tagnum(&G__PamVMC_fcCintLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__PamVMC_fcCintLN_PamVMCAcDig))) {
     PamVMCAcDig *G__Lderived;
     G__Lderived=(PamVMCAcDig*)0x1000;
     {
       PamVMCDigitizer *G__Lpbase=(PamVMCDigitizer*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__PamVMC_fcCintLN_PamVMCAcDig),G__get_linked_tagnum(&G__PamVMC_fcCintLN_PamVMCDigitizer),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__PamVMC_fcCintLN_PamVMCAcDig),G__get_linked_tagnum(&G__PamVMC_fcCintLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__PamVMC_fcCintLN_PamVMCCaloDig))) {
     PamVMCCaloDig *G__Lderived;
     G__Lderived=(PamVMCCaloDig*)0x1000;
     {
       PamVMCDigitizer *G__Lpbase=(PamVMCDigitizer*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__PamVMC_fcCintLN_PamVMCCaloDig),G__get_linked_tagnum(&G__PamVMC_fcCintLN_PamVMCDigitizer),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__PamVMC_fcCintLN_PamVMCCaloDig),G__get_linked_tagnum(&G__PamVMC_fcCintLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__PamVMC_fcCintLN_PamVMCS4Dig))) {
     PamVMCS4Dig *G__Lderived;
     G__Lderived=(PamVMCS4Dig*)0x1000;
     {
       PamVMCDigitizer *G__Lpbase=(PamVMCDigitizer*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__PamVMC_fcCintLN_PamVMCS4Dig),G__get_linked_tagnum(&G__PamVMC_fcCintLN_PamVMCDigitizer),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__PamVMC_fcCintLN_PamVMCS4Dig),G__get_linked_tagnum(&G__PamVMC_fcCintLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__PamVMC_fcCintLN_PamVMCNDDig))) {
     PamVMCNDDig *G__Lderived;
     G__Lderived=(PamVMCNDDig*)0x1000;
     {
       PamVMCDigitizer *G__Lpbase=(PamVMCDigitizer*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__PamVMC_fcCintLN_PamVMCNDDig),G__get_linked_tagnum(&G__PamVMC_fcCintLN_PamVMCDigitizer),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__PamVMC_fcCintLN_PamVMCNDDig),G__get_linked_tagnum(&G__PamVMC_fcCintLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__PamVMC_fcCintLN_PamVMCParticle))) {
     PamVMCParticle *G__Lderived;
     G__Lderived=(PamVMCParticle*)0x1000;
     {
       TParticle *G__Lpbase=(TParticle*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__PamVMC_fcCintLN_PamVMCParticle),G__get_linked_tagnum(&G__PamVMC_fcCintLN_TParticle),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__PamVMC_fcCintLN_PamVMCParticle),G__get_linked_tagnum(&G__PamVMC_fcCintLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TAttLine *G__Lpbase=(TAttLine*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__PamVMC_fcCintLN_PamVMCParticle),G__get_linked_tagnum(&G__PamVMC_fcCintLN_TAttLine),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TAtt3D *G__Lpbase=(TAtt3D*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__PamVMC_fcCintLN_PamVMCParticle),G__get_linked_tagnum(&G__PamVMC_fcCintLN_TAtt3D),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__PamVMC_fcCintLN_PamVMCStack))) {
     PamVMCStack *G__Lderived;
     G__Lderived=(PamVMCStack*)0x1000;
     {
       TVirtualMCStack *G__Lpbase=(TVirtualMCStack*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__PamVMC_fcCintLN_PamVMCStack),G__get_linked_tagnum(&G__PamVMC_fcCintLN_TVirtualMCStack),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__PamVMC_fcCintLN_PamVMCStack),G__get_linked_tagnum(&G__PamVMC_fcCintLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__PamVMC_fcCintLN_PamVMCDetectorSD))) {
     PamVMCDetectorSD *G__Lderived;
     G__Lderived=(PamVMCDetectorSD*)0x1000;
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__PamVMC_fcCintLN_PamVMCDetectorSD),G__get_linked_tagnum(&G__PamVMC_fcCintLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__PamVMC_fcCintLN_PamVMCPrimary))) {
     PamVMCPrimary *G__Lderived;
     G__Lderived=(PamVMCPrimary*)0x1000;
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__PamVMC_fcCintLN_PamVMCPrimary),G__get_linked_tagnum(&G__PamVMC_fcCintLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__PamVMC_fcCintLN_PamVMCPrimaryGenerator))) {
     PamVMCPrimaryGenerator *G__Lderived;
     G__Lderived=(PamVMCPrimaryGenerator*)0x1000;
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__PamVMC_fcCintLN_PamVMCPrimaryGenerator),G__get_linked_tagnum(&G__PamVMC_fcCintLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__PamVMC_fcCintLN_pCutControl))) {
     pCutControl *G__Lderived;
     G__Lderived=(pCutControl*)0x1000;
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__PamVMC_fcCintLN_pCutControl),G__get_linked_tagnum(&G__PamVMC_fcCintLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__PamVMC_fcCintLN_PamVMCDetGeom))) {
     PamVMCDetGeom *G__Lderived;
     G__Lderived=(PamVMCDetGeom*)0x1000;
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__PamVMC_fcCintLN_PamVMCDetGeom),G__get_linked_tagnum(&G__PamVMC_fcCintLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__PamVMC_fcCintLN_PamVMCDetector))) {
     PamVMCDetector *G__Lderived;
     G__Lderived=(PamVMCDetector*)0x1000;
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__PamVMC_fcCintLN_PamVMCDetector),G__get_linked_tagnum(&G__PamVMC_fcCintLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__PamVMC_fcCintLN_PamVMCCaloSD))) {
     PamVMCCaloSD *G__Lderived;
     G__Lderived=(PamVMCCaloSD*)0x1000;
     {
       PamVMCDetectorSD *G__Lpbase=(PamVMCDetectorSD*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__PamVMC_fcCintLN_PamVMCCaloSD),G__get_linked_tagnum(&G__PamVMC_fcCintLN_PamVMCDetectorSD),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__PamVMC_fcCintLN_PamVMCCaloSD),G__get_linked_tagnum(&G__PamVMC_fcCintLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__PamVMC_fcCintLN_PamVMCDetCalo))) {
     PamVMCDetCalo *G__Lderived;
     G__Lderived=(PamVMCDetCalo*)0x1000;
     {
       PamVMCDetector *G__Lpbase=(PamVMCDetector*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__PamVMC_fcCintLN_PamVMCDetCalo),G__get_linked_tagnum(&G__PamVMC_fcCintLN_PamVMCDetector),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__PamVMC_fcCintLN_PamVMCDetCalo),G__get_linked_tagnum(&G__PamVMC_fcCintLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__PamVMC_fcCintLN_pTrkHitData))) {
     pTrkHitData *G__Lderived;
     G__Lderived=(pTrkHitData*)0x1000;
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__PamVMC_fcCintLN_pTrkHitData),G__get_linked_tagnum(&G__PamVMC_fcCintLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__PamVMC_fcCintLN_PamVMCTrkHit))) {
     PamVMCTrkHit *G__Lderived;
     G__Lderived=(PamVMCTrkHit*)0x1000;
     {
       PamVMCDetectorHit *G__Lpbase=(PamVMCDetectorHit*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__PamVMC_fcCintLN_PamVMCTrkHit),G__get_linked_tagnum(&G__PamVMC_fcCintLN_PamVMCDetectorHit),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__PamVMC_fcCintLN_PamVMCTrkHit),G__get_linked_tagnum(&G__PamVMC_fcCintLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__PamVMC_fcCintLN_PamVMCTrkSD))) {
     PamVMCTrkSD *G__Lderived;
     G__Lderived=(PamVMCTrkSD*)0x1000;
     {
       PamVMCDetectorSD *G__Lpbase=(PamVMCDetectorSD*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__PamVMC_fcCintLN_PamVMCTrkSD),G__get_linked_tagnum(&G__PamVMC_fcCintLN_PamVMCDetectorSD),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__PamVMC_fcCintLN_PamVMCTrkSD),G__get_linked_tagnum(&G__PamVMC_fcCintLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__PamVMC_fcCintLN_PamVMCDetTrk))) {
     PamVMCDetTrk *G__Lderived;
     G__Lderived=(PamVMCDetTrk*)0x1000;
     {
       PamVMCDetector *G__Lpbase=(PamVMCDetector*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__PamVMC_fcCintLN_PamVMCDetTrk),G__get_linked_tagnum(&G__PamVMC_fcCintLN_PamVMCDetector),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__PamVMC_fcCintLN_PamVMCDetTrk),G__get_linked_tagnum(&G__PamVMC_fcCintLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__PamVMC_fcCintLN_PamVMCTofSD))) {
     PamVMCTofSD *G__Lderived;
     G__Lderived=(PamVMCTofSD*)0x1000;
     {
       PamVMCDetectorSD *G__Lpbase=(PamVMCDetectorSD*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__PamVMC_fcCintLN_PamVMCTofSD),G__get_linked_tagnum(&G__PamVMC_fcCintLN_PamVMCDetectorSD),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__PamVMC_fcCintLN_PamVMCTofSD),G__get_linked_tagnum(&G__PamVMC_fcCintLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__PamVMC_fcCintLN_PamVMCDetTofS1))) {
     PamVMCDetTofS1 *G__Lderived;
     G__Lderived=(PamVMCDetTofS1*)0x1000;
     {
       PamVMCDetector *G__Lpbase=(PamVMCDetector*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__PamVMC_fcCintLN_PamVMCDetTofS1),G__get_linked_tagnum(&G__PamVMC_fcCintLN_PamVMCDetector),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__PamVMC_fcCintLN_PamVMCDetTofS1),G__get_linked_tagnum(&G__PamVMC_fcCintLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__PamVMC_fcCintLN_PamVMCDetTofS2))) {
     PamVMCDetTofS2 *G__Lderived;
     G__Lderived=(PamVMCDetTofS2*)0x1000;
     {
       PamVMCDetector *G__Lpbase=(PamVMCDetector*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__PamVMC_fcCintLN_PamVMCDetTofS2),G__get_linked_tagnum(&G__PamVMC_fcCintLN_PamVMCDetector),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__PamVMC_fcCintLN_PamVMCDetTofS2),G__get_linked_tagnum(&G__PamVMC_fcCintLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__PamVMC_fcCintLN_PamVMCDetTofS3))) {
     PamVMCDetTofS3 *G__Lderived;
     G__Lderived=(PamVMCDetTofS3*)0x1000;
     {
       PamVMCDetector *G__Lpbase=(PamVMCDetector*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__PamVMC_fcCintLN_PamVMCDetTofS3),G__get_linked_tagnum(&G__PamVMC_fcCintLN_PamVMCDetector),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__PamVMC_fcCintLN_PamVMCDetTofS3),G__get_linked_tagnum(&G__PamVMC_fcCintLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__PamVMC_fcCintLN_PamVMCDetTof))) {
     PamVMCDetTof *G__Lderived;
     G__Lderived=(PamVMCDetTof*)0x1000;
     {
       PamVMCDetector *G__Lpbase=(PamVMCDetector*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__PamVMC_fcCintLN_PamVMCDetTof),G__get_linked_tagnum(&G__PamVMC_fcCintLN_PamVMCDetector),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__PamVMC_fcCintLN_PamVMCDetTof),G__get_linked_tagnum(&G__PamVMC_fcCintLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__PamVMC_fcCintLN_PamVMCCardSD))) {
     PamVMCCardSD *G__Lderived;
     G__Lderived=(PamVMCCardSD*)0x1000;
     {
       PamVMCDetectorSD *G__Lpbase=(PamVMCDetectorSD*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__PamVMC_fcCintLN_PamVMCCardSD),G__get_linked_tagnum(&G__PamVMC_fcCintLN_PamVMCDetectorSD),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__PamVMC_fcCintLN_PamVMCCardSD),G__get_linked_tagnum(&G__PamVMC_fcCintLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__PamVMC_fcCintLN_PamVMCDetCard))) {
     PamVMCDetCard *G__Lderived;
     G__Lderived=(PamVMCDetCard*)0x1000;
     {
       PamVMCDetector *G__Lpbase=(PamVMCDetector*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__PamVMC_fcCintLN_PamVMCDetCard),G__get_linked_tagnum(&G__PamVMC_fcCintLN_PamVMCDetector),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__PamVMC_fcCintLN_PamVMCDetCard),G__get_linked_tagnum(&G__PamVMC_fcCintLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__PamVMC_fcCintLN_PamVMCCasSD))) {
     PamVMCCasSD *G__Lderived;
     G__Lderived=(PamVMCCasSD*)0x1000;
     {
       PamVMCDetectorSD *G__Lpbase=(PamVMCDetectorSD*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__PamVMC_fcCintLN_PamVMCCasSD),G__get_linked_tagnum(&G__PamVMC_fcCintLN_PamVMCDetectorSD),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__PamVMC_fcCintLN_PamVMCCasSD),G__get_linked_tagnum(&G__PamVMC_fcCintLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__PamVMC_fcCintLN_PamVMCDetCas))) {
     PamVMCDetCas *G__Lderived;
     G__Lderived=(PamVMCDetCas*)0x1000;
     {
       PamVMCDetector *G__Lpbase=(PamVMCDetector*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__PamVMC_fcCintLN_PamVMCDetCas),G__get_linked_tagnum(&G__PamVMC_fcCintLN_PamVMCDetector),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__PamVMC_fcCintLN_PamVMCDetCas),G__get_linked_tagnum(&G__PamVMC_fcCintLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__PamVMC_fcCintLN_PamVMCCatSD))) {
     PamVMCCatSD *G__Lderived;
     G__Lderived=(PamVMCCatSD*)0x1000;
     {
       PamVMCDetectorSD *G__Lpbase=(PamVMCDetectorSD*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__PamVMC_fcCintLN_PamVMCCatSD),G__get_linked_tagnum(&G__PamVMC_fcCintLN_PamVMCDetectorSD),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__PamVMC_fcCintLN_PamVMCCatSD),G__get_linked_tagnum(&G__PamVMC_fcCintLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__PamVMC_fcCintLN_PamVMCDetCat))) {
     PamVMCDetCat *G__Lderived;
     G__Lderived=(PamVMCDetCat*)0x1000;
     {
       PamVMCDetector *G__Lpbase=(PamVMCDetector*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__PamVMC_fcCintLN_PamVMCDetCat),G__get_linked_tagnum(&G__PamVMC_fcCintLN_PamVMCDetector),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__PamVMC_fcCintLN_PamVMCDetCat),G__get_linked_tagnum(&G__PamVMC_fcCintLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__PamVMC_fcCintLN_PamVMCDetAc))) {
     PamVMCDetAc *G__Lderived;
     G__Lderived=(PamVMCDetAc*)0x1000;
     {
       PamVMCDetector *G__Lpbase=(PamVMCDetector*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__PamVMC_fcCintLN_PamVMCDetAc),G__get_linked_tagnum(&G__PamVMC_fcCintLN_PamVMCDetector),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__PamVMC_fcCintLN_PamVMCDetAc),G__get_linked_tagnum(&G__PamVMC_fcCintLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__PamVMC_fcCintLN_PamVMCS4SD))) {
     PamVMCS4SD *G__Lderived;
     G__Lderived=(PamVMCS4SD*)0x1000;
     {
       PamVMCDetectorSD *G__Lpbase=(PamVMCDetectorSD*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__PamVMC_fcCintLN_PamVMCS4SD),G__get_linked_tagnum(&G__PamVMC_fcCintLN_PamVMCDetectorSD),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__PamVMC_fcCintLN_PamVMCS4SD),G__get_linked_tagnum(&G__PamVMC_fcCintLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__PamVMC_fcCintLN_PamVMCDetS4))) {
     PamVMCDetS4 *G__Lderived;
     G__Lderived=(PamVMCDetS4*)0x1000;
     {
       PamVMCDetector *G__Lpbase=(PamVMCDetector*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__PamVMC_fcCintLN_PamVMCDetS4),G__get_linked_tagnum(&G__PamVMC_fcCintLN_PamVMCDetector),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__PamVMC_fcCintLN_PamVMCDetS4),G__get_linked_tagnum(&G__PamVMC_fcCintLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__PamVMC_fcCintLN_PamVMCNDSD))) {
     PamVMCNDSD *G__Lderived;
     G__Lderived=(PamVMCNDSD*)0x1000;
     {
       PamVMCDetectorSD *G__Lpbase=(PamVMCDetectorSD*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__PamVMC_fcCintLN_PamVMCNDSD),G__get_linked_tagnum(&G__PamVMC_fcCintLN_PamVMCDetectorSD),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__PamVMC_fcCintLN_PamVMCNDSD),G__get_linked_tagnum(&G__PamVMC_fcCintLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__PamVMC_fcCintLN_PamVMCDetND))) {
     PamVMCDetND *G__Lderived;
     G__Lderived=(PamVMCDetND*)0x1000;
     {
       PamVMCDetector *G__Lpbase=(PamVMCDetector*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__PamVMC_fcCintLN_PamVMCDetND),G__get_linked_tagnum(&G__PamVMC_fcCintLN_PamVMCDetector),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__PamVMC_fcCintLN_PamVMCDetND),G__get_linked_tagnum(&G__PamVMC_fcCintLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__PamVMC_fcCintLN_PamVMCDetPamela))) {
     PamVMCDetPamela *G__Lderived;
     G__Lderived=(PamVMCDetPamela*)0x1000;
     {
       PamVMCDetector *G__Lpbase=(PamVMCDetector*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__PamVMC_fcCintLN_PamVMCDetPamela),G__get_linked_tagnum(&G__PamVMC_fcCintLN_PamVMCDetector),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__PamVMC_fcCintLN_PamVMCDetPamela),G__get_linked_tagnum(&G__PamVMC_fcCintLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__PamVMC_fcCintLN_PamVMCApplication))) {
     PamVMCApplication *G__Lderived;
     G__Lderived=(PamVMCApplication*)0x1000;
     {
       TVirtualMCApplication *G__Lpbase=(TVirtualMCApplication*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__PamVMC_fcCintLN_PamVMCApplication),G__get_linked_tagnum(&G__PamVMC_fcCintLN_TVirtualMCApplication),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__PamVMC_fcCintLN_PamVMCApplication),G__get_linked_tagnum(&G__PamVMC_fcCintLN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__PamVMC_fcCintLN_PamVMCApplication),G__get_linked_tagnum(&G__PamVMC_fcCintLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
}

/*********************************************************
* typedef information setup/
*********************************************************/
extern "C" void G__cpp_setup_typetablePamVMC_fcCint() {

   /* Setting up typedef entry */
   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("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<ROOT::TSchemaHelper>",117,G__get_linked_tagnum(&G__PamVMC_fcCintLN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__PamVMC_fcCintLN_reverse_iteratorlEvectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__PamVMC_fcCintLN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__PamVMC_fcCintLN_reverse_iteratorlEvectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__PamVMC_fcCintLN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<TVirtualArray*>",117,G__get_linked_tagnum(&G__PamVMC_fcCintLN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__PamVMC_fcCintLN_reverse_iteratorlEvectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__PamVMC_fcCintLN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__PamVMC_fcCintLN_reverse_iteratorlEvectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__PamVMC_fcCintLN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("iterator<std::bidirectional_iterator_tag,TObject*,std::ptrdiff_t,const TObject**,const TObject*&>",117,G__get_linked_tagnum(&G__PamVMC_fcCintLN_iteratorlEbidirectional_iterator_tagcOTObjectmUcOlongcOconstsPTObjectmUmUcOconstsPTObjectmUaNgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("iterator<bidirectional_iterator_tag,TObject*,std::ptrdiff_t,const TObject**,const TObject*&>",117,G__get_linked_tagnum(&G__PamVMC_fcCintLN_iteratorlEbidirectional_iterator_tagcOTObjectmUcOlongcOconstsPTObjectmUmUcOconstsPTObjectmUaNgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("iterator<bidirectional_iterator_tag,TObject*>",117,G__get_linked_tagnum(&G__PamVMC_fcCintLN_iteratorlEbidirectional_iterator_tagcOTObjectmUcOlongcOconstsPTObjectmUmUcOconstsPTObjectmUaNgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("iterator<bidirectional_iterator_tag,TObject*,long>",117,G__get_linked_tagnum(&G__PamVMC_fcCintLN_iteratorlEbidirectional_iterator_tagcOTObjectmUcOlongcOconstsPTObjectmUmUcOconstsPTObjectmUaNgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("iterator<bidirectional_iterator_tag,TObject*,long,const TObject**>",117,G__get_linked_tagnum(&G__PamVMC_fcCintLN_iteratorlEbidirectional_iterator_tagcOTObjectmUcOlongcOconstsPTObjectmUmUcOconstsPTObjectmUaNgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<std::string,TObjArray*>",117,G__get_linked_tagnum(&G__PamVMC_fcCintLN_maplEstringcOTObjArraymUcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOTObjArraymUgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<string,TObjArray*>",117,G__get_linked_tagnum(&G__PamVMC_fcCintLN_maplEstringcOTObjArraymUcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOTObjArraymUgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<string,TObjArray*>",117,G__get_linked_tagnum(&G__PamVMC_fcCintLN_maplEstringcOTObjArraymUcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOTObjArraymUgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<string,TObjArray*,less<string> >",117,G__get_linked_tagnum(&G__PamVMC_fcCintLN_maplEstringcOTObjArraymUcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOTObjArraymUgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixTBase<Float_t>",117,G__get_linked_tagnum(&G__PamVMC_fcCintLN_TMatrixTBaselEfloatgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixTBase<Double_t>",117,G__get_linked_tagnum(&G__PamVMC_fcCintLN_TMatrixTBaselEdoublegR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TVectorT<Float_t>",117,G__get_linked_tagnum(&G__PamVMC_fcCintLN_TVectorTlEfloatgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TVectorT<Double_t>",117,G__get_linked_tagnum(&G__PamVMC_fcCintLN_TVectorTlEdoublegR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixT<Float_t>",117,G__get_linked_tagnum(&G__PamVMC_fcCintLN_TMatrixTlEfloatgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixTRow_const<Float_t>",117,G__get_linked_tagnum(&G__PamVMC_fcCintLN_TMatrixTRow_constlEfloatgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixTColumn_const<Float_t>",117,G__get_linked_tagnum(&G__PamVMC_fcCintLN_TMatrixTColumn_constlEfloatgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixTDiag_const<Float_t>",117,G__get_linked_tagnum(&G__PamVMC_fcCintLN_TMatrixTDiag_constlEfloatgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixTFlat_const<Float_t>",117,G__get_linked_tagnum(&G__PamVMC_fcCintLN_TMatrixTFlat_constlEfloatgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixTSub_const<Float_t>",117,G__get_linked_tagnum(&G__PamVMC_fcCintLN_TMatrixTSub_constlEfloatgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixTSparseRow_const<Float_t>",117,G__get_linked_tagnum(&G__PamVMC_fcCintLN_TMatrixTSparseRow_constlEfloatgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixTSparseDiag_const<Float_t>",117,G__get_linked_tagnum(&G__PamVMC_fcCintLN_TMatrixTSparseDiag_constlEfloatgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixTRow<Float_t>",117,G__get_linked_tagnum(&G__PamVMC_fcCintLN_TMatrixTRowlEfloatgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixTColumn<Float_t>",117,G__get_linked_tagnum(&G__PamVMC_fcCintLN_TMatrixTColumnlEfloatgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixTDiag<Float_t>",117,G__get_linked_tagnum(&G__PamVMC_fcCintLN_TMatrixTDiaglEfloatgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixTFlat<Float_t>",117,G__get_linked_tagnum(&G__PamVMC_fcCintLN_TMatrixTFlatlEfloatgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixTSub<Float_t>",117,G__get_linked_tagnum(&G__PamVMC_fcCintLN_TMatrixTSublEfloatgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixTSparseRow<Float_t>",117,G__get_linked_tagnum(&G__PamVMC_fcCintLN_TMatrixTSparseRowlEfloatgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixTSparseDiag<Float_t>",117,G__get_linked_tagnum(&G__PamVMC_fcCintLN_TMatrixTSparseDiaglEfloatgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TElementActionT<Float_t>",117,G__get_linked_tagnum(&G__PamVMC_fcCintLN_TElementActionTlEfloatgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TElementPosActionT<Float_t>",117,G__get_linked_tagnum(&G__PamVMC_fcCintLN_TElementPosActionTlEfloatgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<UInt_t>",117,G__get_linked_tagnum(&G__PamVMC_fcCintLN_vectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<TString>",117,G__get_linked_tagnum(&G__PamVMC_fcCintLN_vectorlETStringcOallocatorlETStringgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__PamVMC_fcCintLN_reverse_iteratorlEvectorlETStringcOallocatorlETStringgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__PamVMC_fcCintLN_vectorlETStringcOallocatorlETStringgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__PamVMC_fcCintLN_reverse_iteratorlEvectorlETStringcOallocatorlETStringgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__PamVMC_fcCintLN_vectorlETStringcOallocatorlETStringgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("pair<UInt_t,Int_t>",117,G__get_linked_tagnum(&G__PamVMC_fcCintLN_pairlEunsignedsPintcOintgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<std::pair<UInt_t,Int_t> >",117,G__get_linked_tagnum(&G__PamVMC_fcCintLN_vectorlEpairlEunsignedsPintcOintgRcOallocatorlEpairlEunsignedsPintcOintgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<pair<UInt_t,Int_t> >",117,G__get_linked_tagnum(&G__PamVMC_fcCintLN_vectorlEpairlEunsignedsPintcOintgRcOallocatorlEpairlEunsignedsPintcOintgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__PamVMC_fcCintLN_reverse_iteratorlEvectorlEpairlEunsignedsPintcOintgRcOallocatorlEpairlEunsignedsPintcOintgRsPgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__PamVMC_fcCintLN_vectorlEpairlEunsignedsPintcOintgRcOallocatorlEpairlEunsignedsPintcOintgRsPgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__PamVMC_fcCintLN_reverse_iteratorlEvectorlEpairlEunsignedsPintcOintgRcOallocatorlEpairlEunsignedsPintcOintgRsPgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__PamVMC_fcCintLN_vectorlEpairlEunsignedsPintcOintgRcOallocatorlEpairlEunsignedsPintcOintgRsPgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<pair<unsigned int,int> >",117,G__get_linked_tagnum(&G__PamVMC_fcCintLN_vectorlEpairlEunsignedsPintcOintgRcOallocatorlEpairlEunsignedsPintcOintgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<FldKey,double>",117,G__get_linked_tagnum(&G__PamVMC_fcCintLN_maplEintcOdoublecOlesslEintgRcOallocatorlEpairlEconstsPintcOdoublegRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<int,double>",117,G__get_linked_tagnum(&G__PamVMC_fcCintLN_maplEintcOdoublecOlesslEintgRcOallocatorlEpairlEconstsPintcOdoublegRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<int,double,less<int> >",117,G__get_linked_tagnum(&G__PamVMC_fcCintLN_maplEintcOdoublecOlesslEintgRcOallocatorlEpairlEconstsPintcOdoublegRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<UChar_t>",117,G__get_linked_tagnum(&G__PamVMC_fcCintLN_vectorlEunsignedsPcharcOallocatorlEunsignedsPchargRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<UShort_t>",117,G__get_linked_tagnum(&G__PamVMC_fcCintLN_vectorlEunsignedsPshortcOallocatorlEunsignedsPshortgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<PamVMCDetectorHit*>",117,G__get_linked_tagnum(&G__PamVMC_fcCintLN_vectorlEPamVMCDetectorHitmUcOallocatorlEPamVMCDetectorHitmUgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__PamVMC_fcCintLN_reverse_iteratorlEvectorlEPamVMCDetectorHitmUcOallocatorlEPamVMCDetectorHitmUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__PamVMC_fcCintLN_vectorlEPamVMCDetectorHitmUcOallocatorlEPamVMCDetectorHitmUgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__PamVMC_fcCintLN_reverse_iteratorlEvectorlEPamVMCDetectorHitmUcOallocatorlEPamVMCDetectorHitmUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__PamVMC_fcCintLN_vectorlEPamVMCDetectorHitmUcOallocatorlEPamVMCDetectorHitmUgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<Double_t>",117,G__get_linked_tagnum(&G__PamVMC_fcCintLN_vectorlEdoublecOallocatorlEdoublegRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("deque<PamVMCParticle*>",117,G__get_linked_tagnum(&G__PamVMC_fcCintLN_dequelEPamVMCParticlemUcOallocatorlEPamVMCParticlemUgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("stack<PamVMCParticle*>",117,G__get_linked_tagnum(&G__PamVMC_fcCintLN_stacklEPamVMCParticlemUcOdequelEPamVMCParticlemUcOallocatorlEPamVMCParticlemUgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<const pamela::PacketType*,TTree*>",117,G__get_linked_tagnum(&G__PamVMC_fcCintLN_maplEconstsPpamelacLcLPacketTypemUcOTTreemUcOlesslEconstsPpamelacLcLPacketTypemUgRcOallocatorlEpairlEconstsPpamelacLcLPacketTypemUsPconstcOTTreemUgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<const pamela::PacketType*,TTree*,less<const pamela::PacketType*> >",117,G__get_linked_tagnum(&G__PamVMC_fcCintLN_maplEconstsPpamelacLcLPacketTypemUcOTTreemUcOlesslEconstsPpamelacLcLPacketTypemUgRcOallocatorlEpairlEconstsPpamelacLcLPacketTypemUsPconstcOTTreemUgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("list<TFile*>",117,G__get_linked_tagnum(&G__PamVMC_fcCintLN_listlETFilemUcOallocatorlETFilemUgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("list<TTree*>",117,G__get_linked_tagnum(&G__PamVMC_fcCintLN_listlETTreemUcOallocatorlETTreemUgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<const pamela::PacketType*,TTreeList>",117,G__get_linked_tagnum(&G__PamVMC_fcCintLN_maplEconstsPpamelacLcLPacketTypemUcOlistlETTreemUcOallocatorlETTreemUgRsPgRcOlesslEconstsPpamelacLcLPacketTypemUgRcOallocatorlEpairlEconstsPpamelacLcLPacketTypemUsPconstcOlistlETTreemUcOallocatorlETTreemUgRsPgRsPgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<const pamela::PacketType*,list<TTree*,allocator<TTree*> > >",117,G__get_linked_tagnum(&G__PamVMC_fcCintLN_maplEconstsPpamelacLcLPacketTypemUcOlistlETTreemUcOallocatorlETTreemUgRsPgRcOlesslEconstsPpamelacLcLPacketTypemUgRcOallocatorlEpairlEconstsPpamelacLcLPacketTypemUsPconstcOlistlETTreemUcOallocatorlETTreemUgRsPgRsPgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<const pamela::PacketType*,list<TTree*,allocator<TTree*> >,less<const pamela::PacketType*> >",117,G__get_linked_tagnum(&G__PamVMC_fcCintLN_maplEconstsPpamelacLcLPacketTypemUcOlistlETTreemUcOallocatorlETTreemUgRsPgRcOlesslEconstsPpamelacLcLPacketTypemUgRcOallocatorlEpairlEconstsPpamelacLcLPacketTypemUsPconstcOlistlETTreemUcOallocatorlETTreemUgRsPgRsPgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<std::string,pamela::SubPacket*>",117,G__get_linked_tagnum(&G__PamVMC_fcCintLN_maplEstringcOpamelacLcLSubPacketmUcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOpamelacLcLSubPacketmUgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<string,pamela::SubPacket*>",117,G__get_linked_tagnum(&G__PamVMC_fcCintLN_maplEstringcOpamelacLcLSubPacketmUcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOpamelacLcLSubPacketmUgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<string,pamela::SubPacket*>",117,G__get_linked_tagnum(&G__PamVMC_fcCintLN_maplEstringcOpamelacLcLSubPacketmUcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOpamelacLcLSubPacketmUgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<string,pamela::SubPacket*,less<string> >",117,G__get_linked_tagnum(&G__PamVMC_fcCintLN_maplEstringcOpamelacLcLSubPacketmUcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOpamelacLcLSubPacketmUgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixT<Double_t>",117,G__get_linked_tagnum(&G__PamVMC_fcCintLN_TMatrixTlEdoublegR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixTRow_const<Double_t>",117,G__get_linked_tagnum(&G__PamVMC_fcCintLN_TMatrixTRow_constlEdoublegR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixTColumn_const<Double_t>",117,G__get_linked_tagnum(&G__PamVMC_fcCintLN_TMatrixTColumn_constlEdoublegR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixTDiag_const<Double_t>",117,G__get_linked_tagnum(&G__PamVMC_fcCintLN_TMatrixTDiag_constlEdoublegR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixTFlat_const<Double_t>",117,G__get_linked_tagnum(&G__PamVMC_fcCintLN_TMatrixTFlat_constlEdoublegR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixTSub_const<Double_t>",117,G__get_linked_tagnum(&G__PamVMC_fcCintLN_TMatrixTSub_constlEdoublegR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixTSparseRow_const<Double_t>",117,G__get_linked_tagnum(&G__PamVMC_fcCintLN_TMatrixTSparseRow_constlEdoublegR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixTSparseDiag_const<Double_t>",117,G__get_linked_tagnum(&G__PamVMC_fcCintLN_TMatrixTSparseDiag_constlEdoublegR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixTRow<Double_t>",117,G__get_linked_tagnum(&G__PamVMC_fcCintLN_TMatrixTRowlEdoublegR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixTColumn<Double_t>",117,G__get_linked_tagnum(&G__PamVMC_fcCintLN_TMatrixTColumnlEdoublegR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixTDiag<Double_t>",117,G__get_linked_tagnum(&G__PamVMC_fcCintLN_TMatrixTDiaglEdoublegR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixTFlat<Double_t>",117,G__get_linked_tagnum(&G__PamVMC_fcCintLN_TMatrixTFlatlEdoublegR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixTSub<Double_t>",117,G__get_linked_tagnum(&G__PamVMC_fcCintLN_TMatrixTSublEdoublegR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixTSparseRow<Double_t>",117,G__get_linked_tagnum(&G__PamVMC_fcCintLN_TMatrixTSparseRowlEdoublegR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixTSparseDiag<Double_t>",117,G__get_linked_tagnum(&G__PamVMC_fcCintLN_TMatrixTSparseDiaglEdoublegR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TElementActionT<Double_t>",117,G__get_linked_tagnum(&G__PamVMC_fcCintLN_TElementActionTlEdoublegR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TElementPosActionT<Double_t>",117,G__get_linked_tagnum(&G__PamVMC_fcCintLN_TElementPosActionTlEdoublegR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<PamVMCPlCross*>",117,G__get_linked_tagnum(&G__PamVMC_fcCintLN_vectorlEPamVMCPlCrossmUcOallocatorlEPamVMCPlCrossmUgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__PamVMC_fcCintLN_reverse_iteratorlEvectorlEPamVMCPlCrossmUcOallocatorlEPamVMCPlCrossmUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__PamVMC_fcCintLN_vectorlEPamVMCPlCrossmUcOallocatorlEPamVMCPlCrossmUgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__PamVMC_fcCintLN_reverse_iteratorlEvectorlEPamVMCPlCrossmUcOallocatorlEPamVMCPlCrossmUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__PamVMC_fcCintLN_vectorlEPamVMCPlCrossmUcOallocatorlEPamVMCPlCrossmUgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<Int_t,TGeoElementRN*>",117,G__get_linked_tagnum(&G__PamVMC_fcCintLN_maplEintcOTGeoElementRNmUcOlesslEintgRcOallocatorlEpairlEconstsPintcOTGeoElementRNmUgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<int,TGeoElementRN*>",117,G__get_linked_tagnum(&G__PamVMC_fcCintLN_maplEintcOTGeoElementRNmUcOlesslEintgRcOallocatorlEpairlEconstsPintcOTGeoElementRNmUgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<int,TGeoElementRN*,less<int> >",117,G__get_linked_tagnum(&G__PamVMC_fcCintLN_maplEintcOTGeoElementRNmUcOlesslEintgRcOallocatorlEpairlEconstsPintcOTGeoElementRNmUgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<ThreadData_t*>",117,G__get_linked_tagnum(&G__PamVMC_fcCintLN_vectorlETGeoVolumeAssemblycLcLThreadData_tmUcOallocatorlETGeoVolumeAssemblycLcLThreadData_tmUgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__PamVMC_fcCintLN_reverse_iteratorlEvectorlETGeoVolumeAssemblycLcLThreadData_tmUcOallocatorlETGeoVolumeAssemblycLcLThreadData_tmUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__PamVMC_fcCintLN_vectorlETGeoVolumeAssemblycLcLThreadData_tmUcOallocatorlETGeoVolumeAssemblycLcLThreadData_tmUgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__PamVMC_fcCintLN_reverse_iteratorlEvectorlETGeoVolumeAssemblycLcLThreadData_tmUcOallocatorlETGeoVolumeAssemblycLcLThreadData_tmUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__PamVMC_fcCintLN_vectorlETGeoVolumeAssemblycLcLThreadData_tmUcOallocatorlETGeoVolumeAssemblycLcLThreadData_tmUgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<TGeoVolumeAssembly::ThreadData_t*>",117,G__get_linked_tagnum(&G__PamVMC_fcCintLN_vectorlETGeoVolumeAssemblycLcLThreadData_tmUcOallocatorlETGeoVolumeAssemblycLcLThreadData_tmUgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<Long_t,TGeoNavigatorArray*>",117,G__get_linked_tagnum(&G__PamVMC_fcCintLN_maplElongcOTGeoNavigatorArraymUcOlesslElonggRcOallocatorlEpairlEconstsPlongcOTGeoNavigatorArraymUgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<long,TGeoNavigatorArray*>",117,G__get_linked_tagnum(&G__PamVMC_fcCintLN_maplElongcOTGeoNavigatorArraymUcOlesslElonggRcOallocatorlEpairlEconstsPlongcOTGeoNavigatorArraymUgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<long,TGeoNavigatorArray*,less<long> >",117,G__get_linked_tagnum(&G__PamVMC_fcCintLN_maplElongcOTGeoNavigatorArraymUcOlesslElonggRcOallocatorlEpairlEconstsPlongcOTGeoNavigatorArraymUgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<Long_t,Int_t>",117,G__get_linked_tagnum(&G__PamVMC_fcCintLN_maplElongcOintcOlesslElonggRcOallocatorlEpairlEconstsPlongcOintgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<Int_t,pCombTrans*>",117,G__get_linked_tagnum(&G__PamVMC_fcCintLN_maplEintcOpCombTransmUcOlesslEintgRcOallocatorlEpairlEconstsPintcOpCombTransmUgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<int,pCombTrans*>",117,G__get_linked_tagnum(&G__PamVMC_fcCintLN_maplEintcOpCombTransmUcOlesslEintgRcOallocatorlEpairlEconstsPintcOpCombTransmUgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<int,pCombTrans*,less<int> >",117,G__get_linked_tagnum(&G__PamVMC_fcCintLN_maplEintcOpCombTransmUcOlesslEintgRcOallocatorlEpairlEconstsPintcOpCombTransmUgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
}

/*********************************************************
* Data Member information setup/
*********************************************************/

   /* Setting up class,struct,union tag member variable */

   /* PamRootManager */
static void G__setup_memvarPamRootManager(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__PamVMC_fcCintLN_PamRootManager));
   { PamRootManager *p; p=(PamRootManager*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__PamVMC_fcCintLN_PamRootManager),-1,-2,4,"fgInstance=",0,"Singleton instance");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__PamVMC_fcCintLN_TDirectory),-1,-1,4,"fDirectory=",0,"directory to store root-file");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__PamVMC_fcCintLN_TFile),-1,-1,4,"fFile=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__PamVMC_fcCintLN_TTree),-1,-1,4,"fTree=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__PamVMC_fcCintLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* pHitData */
static void G__setup_memvarpHitData(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__PamVMC_fcCintLN_pHitData));
   { pHitData *p; p=(pHitData*)0x1000; if (p) { }
   G__memvar_setup((void*)((long)(&p->fPOS)-(long)(p)),105,0,0,-1,G__defined_typename("Int_t"),-1,1,"fPOS=",0,(char*)NULL);
   G__memvar_setup((void*)((long)(&p->fPDG)-(long)(p)),105,0,0,-1,G__defined_typename("Int_t"),-1,1,"fPDG=",0,"Particle PDG");
   G__memvar_setup((void*)((long)(&p->fPATH)-(long)(p)),100,0,0,-1,G__defined_typename("Double_t"),-1,1,"fPATH=",0,"PATH length in specific SD in (cm)");
   G__memvar_setup((void*)((long)(&p->fTOF)-(long)(p)),100,0,0,-1,G__defined_typename("Double_t"),-1,1,"fTOF=",0,(char*)NULL);
   G__memvar_setup((void*)((long)(&p->fPIN)-(long)(p)),100,0,0,-1,G__defined_typename("Double_t"),-1,1,"fPIN=",0,(char*)NULL);
   G__memvar_setup((void*)((long)(&p->fXOUT)-(long)(p)),100,0,0,-1,G__defined_typename("Double_t"),-1,1,"fXOUT=",0,(char*)NULL);
   G__memvar_setup((void*)((long)(&p->fYOUT)-(long)(p)),100,0,0,-1,G__defined_typename("Double_t"),-1,1,"fYOUT=",0,(char*)NULL);
   G__memvar_setup((void*)((long)(&p->fZOUT)-(long)(p)),100,0,0,-1,G__defined_typename("Double_t"),-1,1,"fZOUT=",0,(char*)NULL);
   G__memvar_setup((void*)((long)(&p->fEREL)-(long)(p)),100,0,0,-1,G__defined_typename("Double_t"),-1,1,"fEREL=",0,"Energy released during hit");
   G__memvar_setup((void*)((long)(&p->fXIN)-(long)(p)),100,0,0,-1,G__defined_typename("Double_t"),-1,1,"fXIN=",0,(char*)NULL);
   G__memvar_setup((void*)((long)(&p->fYIN)-(long)(p)),100,0,0,-1,G__defined_typename("Double_t"),-1,1,"fYIN=",0,(char*)NULL);
   G__memvar_setup((void*)((long)(&p->fZIN)-(long)(p)),100,0,0,-1,G__defined_typename("Double_t"),-1,1,"fZIN=",0,(char*)NULL);
   G__memvar_setup((void*)((long)(&p->fPRIM)-(long)(p)),103,0,0,-1,G__defined_typename("Bool_t"),-1,1,"fPRIM=",0,"1 if it was a hit from primary particle");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__PamVMC_fcCintLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* PamVMCDetectorHit */
static void G__setup_memvarPamVMCDetectorHit(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__PamVMC_fcCintLN_PamVMCDetectorHit));
   { PamVMCDetectorHit *p; p=(PamVMCDetectorHit*)0x1000; if (p) { }
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__PamVMC_fcCintLN_pHitData),-1,-1,2,"fhitdata=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fnocall=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__PamVMC_fcCintLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* PamVMCOptMgr */
static void G__setup_memvarPamVMCOptMgr(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__PamVMC_fcCintLN_PamVMCOptMgr));
   { PamVMCOptMgr *p; p=(PamVMCOptMgr*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__PamVMC_fcCintLN_PamVMCOptMgr),-1,-2,4,"fopt=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__PamVMC_fcCintLN_TMap),-1,-1,4,"foptmap=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__PamVMC_fcCintLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* PamVMCDigitizer */
static void G__setup_memvarPamVMCDigitizer(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__PamVMC_fcCintLN_PamVMCDigitizer));
   { PamVMCDigitizer *p; p=(PamVMCDigitizer*)0x1000; if (p) { }
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__PamVMC_fcCintLN_TString),-1,-1,2,"fdname=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__PamVMC_fcCintLN_PamVMCSQLMgr),-1,-1,2,"fsql=",0,"pointer to SQL Mgr");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__PamVMC_fcCintLN_PamVMCRawMgr),-1,-1,2,"fraw=",0,"pointer to RAW Mgr");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__PamVMC_fcCintLN_PamVMCRndMgr),-1,-1,2,"frnd=",0,"pointer to random object Mgr");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__PamVMC_fcCintLN_TRandom3),-1,-1,2,"frandom=",0,"a random object. Class is an owner");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__PamVMC_fcCintLN_basic_ifstreamlEcharcOchar_traitslEchargRsPgR),G__defined_typename("ifstream"),-1,2,"fcfile=",0,"binary file with calib data if any");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__PamVMC_fcCintLN_basic_stringstreamlEcharcOchar_traitslEchargRcOallocatorlEchargRsPgR),G__defined_typename("stringstream"),-1,2,"fquery=",0,"query ty mysql ");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fdberr=",0,"error index (check db)");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__PamVMC_fcCintLN_TString),-1,-1,2,"fpath=",0,"path to default calibration datafiles;");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__PamVMC_fcCintLN_TFile),-1,-1,2,"fcrfile=",0,"pointer to file with calibration  ");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__PamVMC_fcCintLN_TMap),-1,-1,2,"fhitscolmap=",0,"vector of hit collections (TClonesArray), given by SD to digitize");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__PamVMC_fcCintLN_vectorlEunsignedsPshortcOallocatorlEunsignedsPshortgRsPgR),G__defined_typename("USBuffer"),-1,2,"fData=",0,"detector's data vector");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__PamVMC_fcCintLN_vectorlEunsignedsPcharcOallocatorlEunsignedsPchargRsPgR),G__defined_typename("UCBuffer"),-1,2,"fDataPSCU=",0,"detector's PSCU data");
   G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,2,"fPadding=",0,"data padding");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__PamVMC_fcCintLN_vectorlEunsignedsPcharcOallocatorlEunsignedsPchargRsPgR),G__defined_typename("UCBuffer"),-1,2,"fDataPadding=",0,"detector's Padding data");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__PamVMC_fcCintLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* GPSSPEData */
static void G__setup_memvarGPSSPEData(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__PamVMC_fcCintLN_GPSSPEData));
   { GPSSPEData *p; p=(GPSSPEData*)0x1000; if (p) { }
   G__memvar_setup((void*)((long)(&p->fistrip)-(long)(p)),105,0,0,-1,G__defined_typename("Int_t"),-1,1,"fistrip=",0,(char*)NULL);
   G__memvar_setup((void*)((long)(&p->fqstrip)-(long)(p)),102,0,0,-1,G__defined_typename("Float_t"),-1,1,"fqstrip=",0,(char*)NULL);
   G__memvar_setup((void*)((long)(&p->fstripc)-(long)(p)),102,0,0,-1,G__defined_typename("Float_t"),-1,1,"fstripc=",0,(char*)NULL);
   G__memvar_setup((void*)((long)(&p->fnpstrip)-(long)(p)),105,0,0,-1,G__defined_typename("Int_t"),-1,1,"fnpstrip=",0,(char*)NULL);
   G__memvar_setup((void*)((long)(&p->fntstrip)-(long)(p)),105,0,0,-1,G__defined_typename("Int_t"),-1,1,"fntstrip=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__PamVMC_fcCintLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* pGPSSPEHits */
static void G__setup_memvarpGPSSPEHits(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__PamVMC_fcCintLN_pGPSSPEHits));
   { pGPSSPEHits *p; p=(pGPSSPEHits*)0x1000; if (p) { }
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fnstrpx=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fnstrpy=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__PamVMC_fcCintLN_TClonesArray),-1,-1,4,"fGPSSPEDataXColl=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__PamVMC_fcCintLN_TClonesArray),-1,-1,4,"fGPSSPEDataYColl=",0,(char*)NULL);
   G__memvar_setup((void*)0,108,0,0,-1,-1,-1,4,"G__virtualinfo=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__PamVMC_fcCintLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* PamVMCTrkDig */
static void G__setup_memvarPamVMCTrkDig(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__PamVMC_fcCintLN_PamVMCTrkDig));
   { PamVMCTrkDig *p; p=(PamVMCTrkDig*)0x1000; if (p) { }
   G__memvar_setup((void*)G__PVOID,105,0,1,-1,G__defined_typename("Int_t"),-2,4,"fNviews=12LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,-1,G__defined_typename("Int_t"),-2,4,"fNladder=3LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,-1,G__defined_typename("Int_t"),-2,4,"fNstrips_ladder=1024LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,-1,G__defined_typename("Int_t"),-2,4,"fNstrips_view=3072LL",0,(char*)NULL);
   G__memvar_setup((void*)0,102,0,1,-1,G__defined_typename("Float_t"),-2,4,"fSigmaCommon=",0,"to be adjusted");
   G__memvar_setup((void*)G__PVOID,105,0,1,-1,G__defined_typename("Int_t"),-2,4,"fCutzop=4LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,-1,G__defined_typename("Int_t"),-2,4,"fCutclu=7LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,-1,G__defined_typename("Int_t"),-2,4,"fNclst=2LL",0,(char*)NULL);
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,4,"fSigmaTrack[12][3072]=",0,(char*)NULL);
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,4,"fPedeTrack[12][3072]=",0,(char*)NULL);
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,4,"AdcTrack[12][3072]=",0,"Vector of strips to be compressed");
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,4,"fMipCor[3][12]=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__PamVMC_fcCintLN_TRandom3),-1,-1,4,"fextrnd=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__PamVMC_fcCintLN_pGPSSPEHits),-1,-1,4,"fhits=",0,"pointer to Tracker's SD hit data");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__PamVMC_fcCintLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* PamVMCTofDig */
static void G__setup_memvarPamVMCTofDig(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__PamVMC_fcCintLN_PamVMCTofDig));
   { PamVMCTofDig *p; p=(PamVMCTofDig*)0x1000; if (p) { }
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,4,"fatte1[48]=",0,(char*)NULL);
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,4,"fatte2[48]=",0,(char*)NULL);
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,4,"flambda1[48]=",0,(char*)NULL);
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,4,"flambda2[48]=",0,(char*)NULL);
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,4,"fQevePmt_pC[48]=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fADCtof[48]=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fTDCint[48]=",0,(char*)NULL);
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,4,"ftdcres[48]=",0,(char*)NULL);
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,4,"fc1_S[48]=",0,(char*)NULL);
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,4,"fc2_S[48]=",0,(char*)NULL);
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,4,"fc3_S[48]=",0,(char*)NULL);
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,4,"ftdc[48]=",0,(char*)NULL);
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,4,"ftdc1[48]=",0,(char*)NULL);
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,4,"ftdcpmt[48]=",0,(char*)NULL);
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fDEBUG=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__PamVMC_fcCintLN_vectorlEunsignedsPcharcOallocatorlEunsignedsPchargRsPgR),G__defined_typename("UCBuffer"),-1,4,"fDataC=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__PamVMC_fcCintLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* PamVMCAcDig */
static void G__setup_memvarPamVMCAcDig(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__PamVMC_fcCintLN_PamVMCAcDig));
   { PamVMCAcDig *p; p=(PamVMCAcDig*)0x1000; if (p) { }
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,4,"fSumEcat[5]=",0,(char*)NULL);
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,4,"fSumEcas[5]=",0,(char*)NULL);
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,4,"fSumEcard[5]=",0,(char*)NULL);
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fDEBUG=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__PamVMC_fcCintLN_TF1),-1,-1,4,"fattenAC=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__PamVMC_fcCintLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* PamVMCCaloDig */
static void G__setup_memvarPamVMCCaloDig(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__PamVMC_fcCintLN_PamVMCCaloDig));
   { PamVMCCaloDig *p; p=(PamVMCCaloDig*)0x1000; if (p) { }
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,4,"fCalomip[2][22][96]=",0,"ADC to MIP conversion values");
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,4,"fcalped[4][11][96]=",0,"pedestals");
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,4,"fcalgood[4][11][96]=",0,"used or not in the common noise calculation");
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,4,"fcalthr[4][11][6]=",0,"thresholds");
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,4,"fcalrms[4][11][96]=",0,"rms");
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,4,"fcalbase[4][11][6]=",0,"baselines (common noise) during calibration");
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,4,"fcalvar[4][11][6]=",0,"variance");
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,4,"fcstwerr[4]=",0,"status word");
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,4,"fcperror[4]=",0,"unpacking error flag");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fevtcalo=",0,(char*)NULL);
   G__memvar_setup((void*)0,114,0,0,-1,G__defined_typename("UShort_t"),-1,4,"fSecCalo[4]=",0,(char*)NULL);
   G__memvar_setup((void*)0,114,0,0,-1,G__defined_typename("UShort_t"),-1,4,"fSecCaloLength[4]=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__PamVMC_fcCintLN_TClonesArray),-1,-1,4,"fhc=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__PamVMC_fcCintLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* PamVMCS4Dig */
static void G__setup_memvarPamVMCS4Dig(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__PamVMC_fcCintLN_PamVMCS4Dig));
   { PamVMCS4Dig *p; p=(PamVMCS4Dig*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__PamVMC_fcCintLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* PamVMCNDDig */
static void G__setup_memvarPamVMCNDDig(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__PamVMC_fcCintLN_PamVMCNDDig));
   { PamVMCNDDig *p; p=(PamVMCNDDig*)0x1000; if (p) { }
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__PamVMC_fcCintLN_vectorlEPamVMCDetectorHitmUcOallocatorlEPamVMCDetectorHitmUgRsPgR),G__defined_typename("pHits"),-1,4,"fpHits=",0,"hits, sorted by time");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__PamVMC_fcCintLN_vectorlEdoublecOallocatorlEdoublegRsPgR),G__defined_typename("vector<Double_t>"),-1,4,"tauHits[36]=",0,"array of vectors, conains tau for hits");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__PamVMC_fcCintLN_vectorlEPamVMCDetectorHitmUcOallocatorlEPamVMCDetectorHitmUgRsPgR),G__defined_typename("pHits"),-1,4,"tubeHits[36]=",0,"hits, sorted by time and by tubes");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__PamVMC_fcCintLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* PamVMCParticle */
static void G__setup_memvarPamVMCParticle(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__PamVMC_fcCintLN_PamVMCParticle));
   { PamVMCParticle *p; p=(PamVMCParticle*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__PamVMC_fcCintLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* PamVMCStack */
static void G__setup_memvarPamVMCStack(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__PamVMC_fcCintLN_PamVMCStack));
   { PamVMCStack *p; p=(PamVMCStack*)0x1000; if (p) { }
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__PamVMC_fcCintLN_stacklEPamVMCParticlemUcOdequelEPamVMCParticlemUcOallocatorlEPamVMCParticlemUgRsPgRsPgR),G__defined_typename("stack<PamVMCParticle*>"),-1,4,"fStack=",0,"!");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__PamVMC_fcCintLN_TClonesArray),-1,-1,4,"fParticles=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fCurrentTrack=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fNPrimary=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__PamVMC_fcCintLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* PamVMCDetectorSD */
static void G__setup_memvarPamVMCDetectorSD(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__PamVMC_fcCintLN_PamVMCDetectorSD));
   { PamVMCDetectorSD *p; p=(PamVMCDetectorSD*)0x1000; if (p) { }
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__PamVMC_fcCintLN_TString),-1,-1,2,"fcname=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__PamVMC_fcCintLN_TString),-1,-1,2,"fdname=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fnohit=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,G__get_linked_tagnum(&G__PamVMC_fcCintLN_fin),-1,-1,2,"ffi=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__PamVMC_fcCintLN_TClonesArray),-1,-1,2,"fHitColl=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__PamVMC_fcCintLN_TMap),-1,-1,2,"fdmap=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__PamVMC_fcCintLN_PamVMCGeoID),-1,-1,2,"fdetID=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__PamVMC_fcCintLN_PamVMCDetectorHit),-1,-1,2,"fhit=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__PamVMC_fcCintLN_PamVMCDigitizer),-1,-1,2,"fdig=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__PamVMC_fcCintLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* PamVMCPrimary */
static void G__setup_memvarPamVMCPrimary(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__PamVMC_fcCintLN_PamVMCPrimary));
   { PamVMCPrimary *p; p=(PamVMCPrimary*)0x1000; if (p) { }
   G__memvar_setup((void*)((long)(&p->fID)-(long)(p)),104,0,0,-1,G__defined_typename("UInt_t"),-1,1,"fID=",0,(char*)NULL);
   G__memvar_setup((void*)((long)(&p->fPDG)-(long)(p)),105,0,0,-1,G__defined_typename("Int_t"),-1,1,"fPDG=",0,(char*)NULL);
   G__memvar_setup((void*)((long)(&p->fX0)-(long)(p)),100,0,0,-1,G__defined_typename("Double_t"),-1,1,"fX0=",0,(char*)NULL);
   G__memvar_setup((void*)((long)(&p->fY0)-(long)(p)),100,0,0,-1,G__defined_typename("Double_t"),-1,1,"fY0=",0,(char*)NULL);
   G__memvar_setup((void*)((long)(&p->fZ0)-(long)(p)),100,0,0,-1,G__defined_typename("Double_t"),-1,1,"fZ0=",0,(char*)NULL);
   G__memvar_setup((void*)((long)(&p->fTHETA)-(long)(p)),100,0,0,-1,G__defined_typename("Double_t"),-1,1,"fTHETA=",0,(char*)NULL);
   G__memvar_setup((void*)((long)(&p->fPHI)-(long)(p)),100,0,0,-1,G__defined_typename("Double_t"),-1,1,"fPHI=",0,(char*)NULL);
   G__memvar_setup((void*)((long)(&p->fP0)-(long)(p)),100,0,0,-1,G__defined_typename("Double_t"),-1,1,"fP0=",0,(char*)NULL);
   G__memvar_setup((void*)((long)(&p->fGOOD)-(long)(p)),103,0,0,-1,G__defined_typename("Bool_t"),-1,1,"fGOOD=",0,(char*)NULL);
   G__memvar_setup((void*)((long)(&p->fXTOL)-(long)(p)),100,0,0,-1,G__defined_typename("Double_t"),-1,1,"fXTOL=",0,(char*)NULL);
   G__memvar_setup((void*)((long)(&p->fYTOL)-(long)(p)),100,0,0,-1,G__defined_typename("Double_t"),-1,1,"fYTOL=",0,(char*)NULL);
   G__memvar_setup((void*)((long)(&p->fCR_X)-(long)(p)),100,0,0,-1,G__defined_typename("Double_t"),-1,1,"fCR_X[14]=",0,(char*)NULL);
   G__memvar_setup((void*)((long)(&p->fCR_Y)-(long)(p)),100,0,0,-1,G__defined_typename("Double_t"),-1,1,"fCR_Y[14]=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__PamVMC_fcCintLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* PamVMCPrimaryGenerator */
static void G__setup_memvarPamVMCPrimaryGenerator(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__PamVMC_fcCintLN_PamVMCPrimaryGenerator));
   { PamVMCPrimaryGenerator *p; p=(PamVMCPrimaryGenerator*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__PamVMC_fcCintLN_TVirtualMCStack),-1,-1,4,"fStack=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fevno=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fngood=",0,"particles inside nominal acceptance");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__PamVMC_fcCintLN_PamVMCPrimary),-1,-1,4,"fprim=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fmass=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fcharge=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fxprev=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fyprev=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fzprev=",0,"coordinates of primary on prev. step");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__PamVMC_fcCintLN_TClonesArray),-1,-1,4,"fprimColl=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__PamVMC_fcCintLN_TRandom),-1,-1,4,"frandom=",0,"Class is not a owner of this object");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__PamVMC_fcCintLN_TF1),-1,-1,4,"ftheta=",0,"To generate sherical distributhin in theta-angle");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__PamVMC_fcCintLN_PamVMC2PiAux),-1,-1,4,"f2PiAux=",0,"2 Pi generator aux stuff");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__PamVMC_fcCintLN_PamVMCPrimaryGF),-1,-1,4,"fpgf=",0,"Object which");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__PamVMC_fcCintLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* pCutControl */
static void G__setup_memvarpCutControl(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__PamVMC_fcCintLN_pCutControl));
   { pCutControl *p; p=(pCutControl*)0x1000; if (p) { }
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fid=",0,"medium id");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fid_m=",0,"medium id in GeoManager");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fCUTGAM=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fBCUTE=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fCUTELE=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fDCUTE=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fCUTNEU=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fCUTHAD=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fCUTMUO=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fDCUTM=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fBCUTM=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fPPCUTM=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fPAIR=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fCOMP=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fPHOT=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fPFIS=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fDRAY=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fANNI=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fBREM=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fHADR=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fMUNU=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fDCAY=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fLOSS=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fMULS=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__PamVMC_fcCintLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* PamVMCDetGeom */
static void G__setup_memvarPamVMCDetGeom(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__PamVMC_fcCintLN_PamVMCDetGeom));
   { PamVMCDetGeom *p; p=(PamVMCDetGeom*)0x1000; if (p) { }
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__PamVMC_fcCintLN_PamVMCDetGeomcLcLkind),-1,-2,2,"MAT=0LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__PamVMC_fcCintLN_PamVMCDetGeomcLcLkind),-1,-2,2,"MED=1LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__PamVMC_fcCintLN_PamVMCDetGeomcLcLkind),-1,-2,2,"VOL=2LL",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__PamVMC_fcCintLN_TString),-1,-1,2,"fdname=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__PamVMC_fcCintLN_TMap),-1,-1,2,"fdrot=",0,"Map of geometry transformations");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__PamVMC_fcCintLN_TObjArray),-1,-1,2,"fmotherprop=",0,"Vector of mother volume to be passed as node of other mother volumes");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__PamVMC_fcCintLN_TMap),-1,-1,2,"fmat=",0,"Map of Material");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__PamVMC_fcCintLN_TMap),-1,-1,2,"fmix=",0,"Mixtures");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__PamVMC_fcCintLN_TMap),-1,-1,2,"fmed=",0,"Mediums");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__PamVMC_fcCintLN_TMap),-1,-1,2,"fvol=",0,"Volumes");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__PamVMC_fcCintLN_TGeoVolume),-1,-1,2,"fmother=",0,"Mother volume of the detector in case of any");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__PamVMC_fcCintLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* PamVMCDetector */
static void G__setup_memvarPamVMCDetector(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__PamVMC_fcCintLN_PamVMCDetector));
   { PamVMCDetector *p; p=(PamVMCDetector*)0x1000; if (p) { }
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__PamVMC_fcCintLN_TString),-1,-1,2,"fdname=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__PamVMC_fcCintLN_TMap),-1,-1,2,"fdetSD=",0,"map of pointers to SD collection");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__PamVMC_fcCintLN_TMap),-1,-1,2,"fsubdet=",0,"map of pointers to subdetectors;");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__PamVMC_fcCintLN_PamVMCDetGeom),-1,-1,2,"fdetgeom=",0,"geometry");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__PamVMC_fcCintLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* PamVMCCaloSD */
static void G__setup_memvarPamVMCCaloSD(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__PamVMC_fcCintLN_PamVMCCaloSD));
   { PamVMCCaloSD *p; p=(PamVMCCaloSD*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__PamVMC_fcCintLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* PamVMCDetCalo */
static void G__setup_memvarPamVMCDetCalo(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__PamVMC_fcCintLN_PamVMCDetCalo));
   { PamVMCDetCalo *p; p=(PamVMCDetCalo*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__PamVMC_fcCintLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* pTrkHitData */
static void G__setup_memvarpTrkHitData(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__PamVMC_fcCintLN_pTrkHitData));
   { pTrkHitData *p; p=(pTrkHitData*)0x1000; if (p) { }
   G__memvar_setup((void*)((long)(&p->fNXMULT)-(long)(p)),105,0,0,-1,G__defined_typename("Int_t"),-1,1,"fNXMULT=",0,(char*)NULL);
   G__memvar_setup((void*)((long)(&p->fNYMULT)-(long)(p)),105,0,0,-1,G__defined_typename("Int_t"),-1,1,"fNYMULT=",0,"Particle PDG");
   G__memvar_setup((void*)((long)(&p->fXAVESPE)-(long)(p)),102,0,0,-1,G__defined_typename("Float_t"),-1,1,"fXAVESPE=",0,"PATH length in specific SD in (cm)");
   G__memvar_setup((void*)((long)(&p->fYAVESPE)-(long)(p)),102,0,0,-1,G__defined_typename("Float_t"),-1,1,"fYAVESPE=",0,(char*)NULL);
   G__memvar_setup((void*)((long)(&p->fZAVESPE)-(long)(p)),102,0,0,-1,G__defined_typename("Float_t"),-1,1,"fZAVESPE=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__PamVMC_fcCintLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* PamVMCTrkHit */
static void G__setup_memvarPamVMCTrkHit(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__PamVMC_fcCintLN_PamVMCTrkHit));
   { PamVMCTrkHit *p; p=(PamVMCTrkHit*)0x1000; if (p) { }
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__PamVMC_fcCintLN_pTrkHitData),-1,-1,2,"ftrkhitdata=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__PamVMC_fcCintLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* PamVMCTrkSD */
static void G__setup_memvarPamVMCTrkSD(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__PamVMC_fcCintLN_PamVMCTrkSD));
   { PamVMCTrkSD *p; p=(PamVMCTrkSD*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__PamVMC_fcCintLN_cGPCSPE),-1,-1,4,"fGPCSPE=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__PamVMC_fcCintLN_cGPSSPE),-1,-1,4,"fGPSSPE=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__PamVMC_fcCintLN_pGPSSPEHits),-1,-1,4,"fgps=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__PamVMC_fcCintLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* PamVMCDetTrk */
static void G__setup_memvarPamVMCDetTrk(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__PamVMC_fcCintLN_PamVMCDetTrk));
   { PamVMCDetTrk *p; p=(PamVMCDetTrk*)0x1000; if (p) { }
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"dxflo[36]=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"dyflo[36]=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__PamVMC_fcCintLN_maplEintcOpCombTransmUcOlesslEintgRcOallocatorlEpairlEconstsPintcOpCombTransmUgRsPgRsPgR),G__defined_typename("CombTransMap"),-1,4,"fctmap=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__PamVMC_fcCintLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* PamVMCTofSD */
static void G__setup_memvarPamVMCTofSD(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__PamVMC_fcCintLN_PamVMCTofSD));
   { PamVMCTofSD *p; p=(PamVMCTofSD*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__PamVMC_fcCintLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* PamVMCDetTofS1 */
static void G__setup_memvarPamVMCDetTofS1(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__PamVMC_fcCintLN_PamVMCDetTofS1));
   { PamVMCDetTofS1 *p; p=(PamVMCDetTofS1*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__PamVMC_fcCintLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* PamVMCDetTofS2 */
static void G__setup_memvarPamVMCDetTofS2(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__PamVMC_fcCintLN_PamVMCDetTofS2));
   { PamVMCDetTofS2 *p; p=(PamVMCDetTofS2*)0x1000; if (p) { }
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"TPLAfirst=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__PamVMC_fcCintLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* PamVMCDetTofS3 */
static void G__setup_memvarPamVMCDetTofS3(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__PamVMC_fcCintLN_PamVMCDetTofS3));
   { PamVMCDetTofS3 *p; p=(PamVMCDetTofS3*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__PamVMC_fcCintLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* PamVMCDetTof */
static void G__setup_memvarPamVMCDetTof(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__PamVMC_fcCintLN_PamVMCDetTof));
   { PamVMCDetTof *p; p=(PamVMCDetTof*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__PamVMC_fcCintLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* PamVMCCardSD */
static void G__setup_memvarPamVMCCardSD(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__PamVMC_fcCintLN_PamVMCCardSD));
   { PamVMCCardSD *p; p=(PamVMCCardSD*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__PamVMC_fcCintLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* PamVMCDetCard */
static void G__setup_memvarPamVMCDetCard(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__PamVMC_fcCintLN_PamVMCDetCard));
   { PamVMCDetCard *p; p=(PamVMCDetCard*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__PamVMC_fcCintLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* PamVMCCasSD */
static void G__setup_memvarPamVMCCasSD(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__PamVMC_fcCintLN_PamVMCCasSD));
   { PamVMCCasSD *p; p=(PamVMCCasSD*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__PamVMC_fcCintLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* PamVMCDetCas */
static void G__setup_memvarPamVMCDetCas(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__PamVMC_fcCintLN_PamVMCDetCas));
   { PamVMCDetCas *p; p=(PamVMCDetCas*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__PamVMC_fcCintLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* PamVMCCatSD */
static void G__setup_memvarPamVMCCatSD(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__PamVMC_fcCintLN_PamVMCCatSD));
   { PamVMCCatSD *p; p=(PamVMCCatSD*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__PamVMC_fcCintLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* PamVMCDetCat */
static void G__setup_memvarPamVMCDetCat(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__PamVMC_fcCintLN_PamVMCDetCat));
   { PamVMCDetCat *p; p=(PamVMCDetCat*)0x1000; if (p) { }
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"TPLAfirst=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__PamVMC_fcCintLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* PamVMCDetAc */
static void G__setup_memvarPamVMCDetAc(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__PamVMC_fcCintLN_PamVMCDetAc));
   { PamVMCDetAc *p; p=(PamVMCDetAc*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__PamVMC_fcCintLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* PamVMCS4SD */
static void G__setup_memvarPamVMCS4SD(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__PamVMC_fcCintLN_PamVMCS4SD));
   { PamVMCS4SD *p; p=(PamVMCS4SD*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__PamVMC_fcCintLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* PamVMCDetS4 */
static void G__setup_memvarPamVMCDetS4(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__PamVMC_fcCintLN_PamVMCDetS4));
   { PamVMCDetS4 *p; p=(PamVMCDetS4*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__PamVMC_fcCintLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* PamVMCNDSD */
static void G__setup_memvarPamVMCNDSD(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__PamVMC_fcCintLN_PamVMCNDSD));
   { PamVMCNDSD *p; p=(PamVMCNDSD*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__PamVMC_fcCintLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* PamVMCDetND */
static void G__setup_memvarPamVMCDetND(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__PamVMC_fcCintLN_PamVMCDetND));
   { PamVMCDetND *p; p=(PamVMCDetND*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__PamVMC_fcCintLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* PamVMCDetPamela */
static void G__setup_memvarPamVMCDetPamela(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__PamVMC_fcCintLN_PamVMCDetPamela));
   { PamVMCDetPamela *p; p=(PamVMCDetPamela*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__PamVMC_fcCintLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* PamVMCApplication */
static void G__setup_memvarPamVMCApplication(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__PamVMC_fcCintLN_PamVMCApplication));
   { PamVMCApplication *p; p=(PamVMCApplication*)0x1000; if (p) { }
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fEventNo=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__PamVMC_fcCintLN_TMCVerbose),-1,-1,4,"fVerbose=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__PamVMC_fcCintLN_PamVMCStack),-1,-1,4,"fStack=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__PamVMC_fcCintLN_PamVMCDetPamela),-1,-1,4,"fdetector=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__PamVMC_fcCintLN_PamVMCPrimaryGenerator),-1,-1,4,"fPrimaryGenerator=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__PamVMC_fcCintLN_PamRootManager),-1,-1,4,"fRootManager=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__PamVMC_fcCintLN_TRandom3),-1,-1,4,"frandom=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,G__get_linked_tagnum(&G__PamVMC_fcCintLN_fin),-1,-1,4,"fdstatus=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"ftrig=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__PamVMC_fcCintLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}

extern "C" void G__cpp_setup_memvarPamVMC_fcCint() {
}
/***********************************************************
************************************************************
************************************************************
************************************************************
************************************************************
************************************************************
************************************************************
***********************************************************/

/*********************************************************
* Member function information setup for each class
*********************************************************/
static void G__setup_memfuncPamRootManager(void) {
   /* PamRootManager */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__PamVMC_fcCintLN_PamRootManager));
   G__memfunc_setup("PamRootManager",1405,G__PamVMC_fcCint_529_0_1, 105, G__get_linked_tagnum(&G__PamVMC_fcCintLN_PamRootManager), -1, 0, 2, 1, 1, 0, 
"C - - 10 - projectName i 'FileMode' - 0 - fileMode", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("PamRootManager",1405,G__PamVMC_fcCint_529_0_2, 105, G__get_linked_tagnum(&G__PamVMC_fcCintLN_PamRootManager), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Instance",821,G__PamVMC_fcCint_529_0_3, 85, G__get_linked_tagnum(&G__PamVMC_fcCintLN_PamRootManager), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (PamRootManager* (*)())(&PamRootManager::Instance) ), 0);
   G__memfunc_setup("Register",837,G__PamVMC_fcCint_529_0_4, 121, -1, -1, 0, 3, 1, 1, 0, 
"C - - 10 - name C - - 10 - className "
"Y - - 0 - objAddress", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Fill",391,G__PamVMC_fcCint_529_0_5, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("WriteAll",804,G__PamVMC_fcCint_529_0_6, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ReadEvent",894,G__PamVMC_fcCint_529_0_7, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__PamVMC_fcCint_529_0_8, 85, G__get_linked_tagnum(&G__PamVMC_fcCintLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&PamRootManager::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__PamVMC_fcCint_529_0_9, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&PamRootManager::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__PamVMC_fcCint_529_0_10, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&PamRootManager::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__PamVMC_fcCint_529_0_11, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&PamRootManager::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__PamVMC_fcCintLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__PamVMC_fcCint_529_0_15, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__PamVMC_fcCint_529_0_16, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&PamRootManager::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__PamVMC_fcCint_529_0_17, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&PamRootManager::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__PamVMC_fcCint_529_0_18, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&PamRootManager::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__PamVMC_fcCint_529_0_19, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&PamRootManager::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("PamRootManager", 1405, G__PamVMC_fcCint_529_0_20, (int) ('i'), G__get_linked_tagnum(&G__PamVMC_fcCintLN_PamRootManager), -1, 0, 1, 1, 1, 0, "u 'PamRootManager' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~PamRootManager", 1531, G__PamVMC_fcCint_529_0_21, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__PamVMC_fcCint_529_0_22, (int) ('u'), G__get_linked_tagnum(&G__PamVMC_fcCintLN_PamRootManager), -1, 1, 1, 1, 1, 0, "u 'PamRootManager' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncpHitData(void) {
   /* pHitData */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__PamVMC_fcCintLN_pHitData));
   G__memfunc_setup("pHitData",783,G__PamVMC_fcCint_614_0_1, 105, G__get_linked_tagnum(&G__PamVMC_fcCintLN_pHitData), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Clean",483,G__PamVMC_fcCint_614_0_2, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Clear",487,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Print",525,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "C - 'Option_t' 10 '\"\"' -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__PamVMC_fcCint_614_0_5, 85, G__get_linked_tagnum(&G__PamVMC_fcCintLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&pHitData::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__PamVMC_fcCint_614_0_6, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&pHitData::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__PamVMC_fcCint_614_0_7, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&pHitData::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__PamVMC_fcCint_614_0_8, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&pHitData::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__PamVMC_fcCintLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__PamVMC_fcCint_614_0_12, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__PamVMC_fcCint_614_0_13, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&pHitData::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__PamVMC_fcCint_614_0_14, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&pHitData::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__PamVMC_fcCint_614_0_15, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&pHitData::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__PamVMC_fcCint_614_0_16, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&pHitData::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("pHitData", 783, G__PamVMC_fcCint_614_0_17, (int) ('i'), G__get_linked_tagnum(&G__PamVMC_fcCintLN_pHitData), -1, 0, 1, 1, 1, 0, "u 'pHitData' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~pHitData", 909, G__PamVMC_fcCint_614_0_18, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__PamVMC_fcCint_614_0_19, (int) ('u'), G__get_linked_tagnum(&G__PamVMC_fcCintLN_pHitData), -1, 1, 1, 1, 1, 0, "u 'pHitData' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncPamVMCDetectorHit(void) {
   /* PamVMCDetectorHit */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__PamVMC_fcCintLN_PamVMCDetectorHit));
   G__memfunc_setup("PamVMCDetectorHit",1635,G__PamVMC_fcCint_615_0_1, 105, G__get_linked_tagnum(&G__PamVMC_fcCintLN_PamVMCDetectorHit), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CleanHit",776,G__PamVMC_fcCint_615_0_2, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Clear",487,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GenHit",575,G__PamVMC_fcCint_615_0_4, 85, G__get_linked_tagnum(&G__PamVMC_fcCintLN_pHitData), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("operator=",937,G__PamVMC_fcCint_615_0_5, 121, -1, -1, 0, 1, 1, 1, 0, "u 'PamVMCDetectorHit' - 11 - p", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator+=",980,G__PamVMC_fcCint_615_0_6, 121, -1, -1, 0, 1, 1, 1, 0, "u 'PamVMCDetectorHit' - 11 - p", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("FillHitEntering",1512,G__PamVMC_fcCint_615_0_7, 121, -1, -1, 0, 1, 1, 1, 0, "u 'pHitData' - 1 - phd", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Print",525,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("FillHit",684,G__PamVMC_fcCint_615_0_9, 121, -1, -1, 0, 2, 1, 1, 0, 
"U 'TVirtualMC' - 0 - g g - 'Bool_t' 0 - is_prim", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetHit",593,G__PamVMC_fcCint_615_0_10, 121, -1, -1, 0, 1, 1, 1, 0, "u 'pHitData' - 11 - phd", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("UpdXIN",536,G__PamVMC_fcCint_615_0_11, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("UpdYIN",537,G__PamVMC_fcCint_615_0_12, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("UpdZIN",538,G__PamVMC_fcCint_615_0_13, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("UpdPIN",528,G__PamVMC_fcCint_615_0_14, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("UpdPDG",516,G__PamVMC_fcCint_615_0_15, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetPOS",542,G__PamVMC_fcCint_615_0_16, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - pos", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetPDG",519,G__PamVMC_fcCint_615_0_17, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - pdg", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddPATH",566,G__PamVMC_fcCint_615_0_18, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - ln", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddEREL",561,G__PamVMC_fcCint_615_0_19, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - de", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetXIN",539,G__PamVMC_fcCint_615_0_20, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - xin", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetYIN",540,G__PamVMC_fcCint_615_0_21, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - yin", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetZIN",541,G__PamVMC_fcCint_615_0_22, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - zin", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetTOF",533,G__PamVMC_fcCint_615_0_23, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - tofin", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetPIN",531,G__PamVMC_fcCint_615_0_24, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - pxin", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetXOUT",636,G__PamVMC_fcCint_615_0_25, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - xout", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetYOUT",637,G__PamVMC_fcCint_615_0_26, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - yout", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetZOUT",638,G__PamVMC_fcCint_615_0_27, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - zout", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetPRIM",612,G__PamVMC_fcCint_615_0_28, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - prim", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Reset",515,G__PamVMC_fcCint_615_0_29, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetHit",581,G__PamVMC_fcCint_615_0_30, 85, G__get_linked_tagnum(&G__PamVMC_fcCintLN_pHitData), -1, 0, 0, 1, 1, 1, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetPOS",530,G__PamVMC_fcCint_615_0_31, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetPDG",507,G__PamVMC_fcCint_615_0_32, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetPATH",589,G__PamVMC_fcCint_615_0_33, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetEREL",584,G__PamVMC_fcCint_615_0_34, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetXIN",527,G__PamVMC_fcCint_615_0_35, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetYIN",528,G__PamVMC_fcCint_615_0_36, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetZIN",529,G__PamVMC_fcCint_615_0_37, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetTOF",521,G__PamVMC_fcCint_615_0_38, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetPIN",519,G__PamVMC_fcCint_615_0_39, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetXOUT",624,G__PamVMC_fcCint_615_0_40, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetYOUT",625,G__PamVMC_fcCint_615_0_41, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetZOUT",626,G__PamVMC_fcCint_615_0_42, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetPRIM",600,G__PamVMC_fcCint_615_0_43, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddTOF",498,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 0, "d - 'Double_t' 0 - tofin", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__PamVMC_fcCint_615_0_45, 85, G__get_linked_tagnum(&G__PamVMC_fcCintLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&PamVMCDetectorHit::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__PamVMC_fcCint_615_0_46, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&PamVMCDetectorHit::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__PamVMC_fcCint_615_0_47, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&PamVMCDetectorHit::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__PamVMC_fcCint_615_0_48, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&PamVMCDetectorHit::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__PamVMC_fcCintLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__PamVMC_fcCint_615_0_52, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__PamVMC_fcCint_615_0_53, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&PamVMCDetectorHit::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__PamVMC_fcCint_615_0_54, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&PamVMCDetectorHit::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__PamVMC_fcCint_615_0_55, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&PamVMCDetectorHit::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__PamVMC_fcCint_615_0_56, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&PamVMCDetectorHit::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("PamVMCDetectorHit", 1635, G__PamVMC_fcCint_615_0_57, (int) ('i'), G__get_linked_tagnum(&G__PamVMC_fcCintLN_PamVMCDetectorHit), -1, 0, 1, 1, 1, 0, "u 'PamVMCDetectorHit' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~PamVMCDetectorHit", 1761, G__PamVMC_fcCint_615_0_58, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncPamVMCOptMgr(void) {
   /* PamVMCOptMgr */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__PamVMC_fcCintLN_PamVMCOptMgr));
   G__memfunc_setup("SetOpt",607,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 2, 1, 4, 0, 
"C - - 10 - name U 'TObject' - 0 - value", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ParseOptions",1255,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "U 'TXMLNode' - 0 - node", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ParseInitOpt",1218,(G__InterfaceMethod) NULL, 85, G__get_linked_tagnum(&G__PamVMC_fcCintLN_pInitModeOpt), -1, 0, 1, 1, 4, 0, "U 'TXMLNode' - 0 - node", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ParseRandomOpt",1423,(G__InterfaceMethod) NULL, 85, G__get_linked_tagnum(&G__PamVMC_fcCintLN_pRandomModeOpt), -1, 0, 1, 1, 4, 0, "U 'TXMLNode' - 0 - node", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ParseRuntimeOpt",1554,(G__InterfaceMethod) NULL, 85, G__get_linked_tagnum(&G__PamVMC_fcCintLN_pRuntimeModeOpt), -1, 0, 1, 1, 4, 0, "U 'TXMLNode' - 0 - node", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ParsePrimaryOpt",1554,(G__InterfaceMethod) NULL, 85, G__get_linked_tagnum(&G__PamVMC_fcCintLN_pPrimaryModeOpt), -1, 0, 1, 1, 4, 0, "U 'TXMLNode' - 0 - node", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("PamVMCOptMgr",1117,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__PamVMC_fcCintLN_PamVMCOptMgr), -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Instance",821,G__PamVMC_fcCint_822_0_8, 85, G__get_linked_tagnum(&G__PamVMC_fcCintLN_PamVMCOptMgr), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (PamVMCOptMgr* (*)())(&PamVMCOptMgr::Instance) ), 0);
   G__memfunc_setup("GetOpt",595,G__PamVMC_fcCint_822_0_9, 85, G__get_linked_tagnum(&G__PamVMC_fcCintLN_TObject), -1, 0, 1, 1, 1, 0, "C - - 10 - name", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Print",525,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "C - 'Option_t' 10 '\"\"' -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ParseFile",891,G__PamVMC_fcCint_822_0_11, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "u 'TString' - 0 - filename", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetOutPath",997,G__PamVMC_fcCint_822_0_12, 117, G__get_linked_tagnum(&G__PamVMC_fcCintLN_TString), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetOutPattern",1334,G__PamVMC_fcCint_822_0_13, 117, G__get_linked_tagnum(&G__PamVMC_fcCintLN_TString), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetOutPatternFull",1737,G__PamVMC_fcCint_822_0_14, 117, G__get_linked_tagnum(&G__PamVMC_fcCintLN_TString), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetTmpPath",990,G__PamVMC_fcCint_822_0_15, 117, G__get_linked_tagnum(&G__PamVMC_fcCintLN_TString), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsUseCookie",1091,G__PamVMC_fcCint_822_0_16, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsNoCalo",760,G__PamVMC_fcCint_822_0_17, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetG4ConfigC",1076,G__PamVMC_fcCint_822_0_18, 117, G__get_linked_tagnum(&G__PamVMC_fcCintLN_TString), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetG4ConfigIn",1192,G__PamVMC_fcCint_822_0_19, 117, G__get_linked_tagnum(&G__PamVMC_fcCintLN_TString), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsReadRandomMode",1566,G__PamVMC_fcCint_822_0_20, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsUserRandomMode",1601,G__PamVMC_fcCint_822_0_21, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetUserRandomSeed",1697,G__PamVMC_fcCint_822_0_22, 121, -1, -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 1 - seed1 i - 'Int_t' 1 - seed2", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoWriteRandom",1311,G__PamVMC_fcCint_822_0_23, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetRandomOutFile",1593,G__PamVMC_fcCint_822_0_24, 117, G__get_linked_tagnum(&G__PamVMC_fcCintLN_TString), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetRandomOutFilename",2010,G__PamVMC_fcCint_822_0_25, 117, G__get_linked_tagnum(&G__PamVMC_fcCintLN_TString), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetRandomInFilename",1881,G__PamVMC_fcCint_822_0_26, 117, G__get_linked_tagnum(&G__PamVMC_fcCintLN_TString), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetVerboseLevel",1518,G__PamVMC_fcCint_822_0_27, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMaxSteps",1109,G__PamVMC_fcCint_822_0_28, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetSaveCond",1075,G__PamVMC_fcCint_822_0_29, 105, G__get_linked_tagnum(&G__PamVMC_fcCintLN_Save_cond), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetSaveMode",1076,G__PamVMC_fcCint_822_0_30, 105, G__get_linked_tagnum(&G__PamVMC_fcCintLN_Save_mode), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetReadPrimMode",1465,G__PamVMC_fcCint_822_0_31, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetReadPrimPath",1473,G__PamVMC_fcCint_822_0_32, 117, G__get_linked_tagnum(&G__PamVMC_fcCintLN_TString), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetPrimPDG",915,G__PamVMC_fcCint_822_0_33, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetPrimMomMode",1382,G__PamVMC_fcCint_822_0_34, 105, G__get_linked_tagnum(&G__PamVMC_fcCintLN_Momentum_mode), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetPrimMomUnits",1524,G__PamVMC_fcCint_822_0_35, 105, G__get_linked_tagnum(&G__PamVMC_fcCintLN_Momentum_units), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMomFixed",1081,G__PamVMC_fcCint_822_0_36, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMomLimits",1211,G__PamVMC_fcCint_822_0_37, 121, -1, -1, 0, 2, 1, 1, 0, 
"d - 'Double_t' 1 - min d - 'Double_t' 1 - max", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMomGamma",1068,G__PamVMC_fcCint_822_0_38, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsCustomKinematics",1855,G__PamVMC_fcCint_822_0_39, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsBoxVertex",1123,G__PamVMC_fcCint_822_0_40, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetFixedPointVertex",1944,G__PamVMC_fcCint_822_0_41, 121, -1, -1, 0, 3, 1, 1, 0, 
"d - 'Double_t' 1 - x0 d - 'Double_t' 1 - y0 "
"d - 'Double_t' 1 - z0", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetBoxVertex",1223,G__PamVMC_fcCint_822_0_42, 121, -1, -1, 0, 6, 1, 1, 0, 
"d - 'Double_t' 1 - x0_min d - 'Double_t' 1 - x0_max "
"d - 'Double_t' 1 - y0_min d - 'Double_t' 1 - y0_max "
"d - 'Double_t' 1 - z0_min d - 'Double_t' 1 - z0_max", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsIsotropicPlane",1640,G__PamVMC_fcCint_822_0_43, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetFixedAngles",1386,G__PamVMC_fcCint_822_0_44, 121, -1, -1, 0, 2, 1, 1, 0, 
"d - 'Double_t' 1 - theta d - 'Double_t' 1 - phi", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetIsotropicAngles",1846,G__PamVMC_fcCint_822_0_45, 121, -1, -1, 0, 4, 1, 1, 0, 
"d - 'Double_t' 1 - theta_min d - 'Double_t' 1 - theta_max "
"d - 'Double_t' 1 - phi_min d - 'Double_t' 1 - phi_max", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetStopMode",1099,G__PamVMC_fcCint_822_0_46, 105, G__get_linked_tagnum(&G__PamVMC_fcCintLN_Nevents_mode), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetEvMax",769,G__PamVMC_fcCint_822_0_47, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__PamVMC_fcCint_822_0_48, 85, G__get_linked_tagnum(&G__PamVMC_fcCintLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&PamVMCOptMgr::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__PamVMC_fcCint_822_0_49, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&PamVMCOptMgr::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__PamVMC_fcCint_822_0_50, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&PamVMCOptMgr::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__PamVMC_fcCint_822_0_51, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&PamVMCOptMgr::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__PamVMC_fcCintLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__PamVMC_fcCint_822_0_55, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__PamVMC_fcCint_822_0_56, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&PamVMCOptMgr::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__PamVMC_fcCint_822_0_57, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&PamVMCOptMgr::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__PamVMC_fcCint_822_0_58, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&PamVMCOptMgr::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__PamVMC_fcCint_822_0_59, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&PamVMCOptMgr::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~PamVMCOptMgr", 1243, G__PamVMC_fcCint_822_0_60, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncPamVMCDigitizer(void) {
   /* PamVMCDigitizer */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__PamVMC_fcCintLN_PamVMCDigitizer));
   G__memfunc_setup("RegisterCollections",1988,G__PamVMC_fcCint_824_0_2, 121, -1, -1, 0, 2, 1, 1, 0, 
"C - - 10 - name U 'TClonesArray' - 0 - hitcoll", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("PrintCollections",1676,G__PamVMC_fcCint_824_0_3, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetRandom",909,G__PamVMC_fcCint_824_0_4, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TRandom3' - 0 - random", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("LoadCalib",859,G__PamVMC_fcCint_824_0_5, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Digitize",825,G__PamVMC_fcCint_824_0_6, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("WriteToBuff",1105,G__PamVMC_fcCint_824_0_7, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("FinishRun",918,G__PamVMC_fcCint_824_0_8, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DigitizePSCU",1140,G__PamVMC_fcCint_824_0_9, 121, -1, -1, 0, 2, 1, 1, 0, 
"h - 'UInt_t' 0 - len b - 'UChar_t' 0 - type", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddPadding",960,G__PamVMC_fcCint_824_0_10, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetPadding",995,G__PamVMC_fcCint_824_0_11, 121, -1, -1, 0, 1, 1, 1, 0, "h - 'UInt_t' 0 - pad", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ThrowCalFileUsage",1689,G__PamVMC_fcCint_824_0_12, 121, -1, -1, 0, 2, 1, 1, 0, 
"C - - 10 - detname C - - 10 - filename", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ThrowCalFileWarning",1914,G__PamVMC_fcCint_824_0_13, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - detname", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__PamVMC_fcCint_824_0_14, 85, G__get_linked_tagnum(&G__PamVMC_fcCintLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&PamVMCDigitizer::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__PamVMC_fcCint_824_0_15, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&PamVMCDigitizer::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__PamVMC_fcCint_824_0_16, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&PamVMCDigitizer::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__PamVMC_fcCint_824_0_17, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&PamVMCDigitizer::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__PamVMC_fcCintLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__PamVMC_fcCint_824_0_21, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__PamVMC_fcCint_824_0_22, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&PamVMCDigitizer::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__PamVMC_fcCint_824_0_23, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&PamVMCDigitizer::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__PamVMC_fcCint_824_0_24, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&PamVMCDigitizer::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__PamVMC_fcCint_824_0_25, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&PamVMCDigitizer::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~PamVMCDigitizer", 1581, G__PamVMC_fcCint_824_0_26, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncGPSSPEData(void) {
   /* GPSSPEData */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__PamVMC_fcCintLN_GPSSPEData));
   G__memfunc_setup("GPSSPEData",844,G__PamVMC_fcCint_826_0_1, 105, G__get_linked_tagnum(&G__PamVMC_fcCintLN_GPSSPEData), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Clean",483,G__PamVMC_fcCint_826_0_2, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Clear",487,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Print",525,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "C - 'Option_t' 10 '\"\"' -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__PamVMC_fcCint_826_0_5, 85, G__get_linked_tagnum(&G__PamVMC_fcCintLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&GPSSPEData::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__PamVMC_fcCint_826_0_6, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&GPSSPEData::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__PamVMC_fcCint_826_0_7, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&GPSSPEData::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__PamVMC_fcCint_826_0_8, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&GPSSPEData::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__PamVMC_fcCintLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__PamVMC_fcCint_826_0_12, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__PamVMC_fcCint_826_0_13, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&GPSSPEData::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__PamVMC_fcCint_826_0_14, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&GPSSPEData::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__PamVMC_fcCint_826_0_15, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&GPSSPEData::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__PamVMC_fcCint_826_0_16, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&GPSSPEData::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("GPSSPEData", 844, G__PamVMC_fcCint_826_0_17, (int) ('i'), G__get_linked_tagnum(&G__PamVMC_fcCintLN_GPSSPEData), -1, 0, 1, 1, 1, 0, "u 'GPSSPEData' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~GPSSPEData", 970, G__PamVMC_fcCint_826_0_18, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__PamVMC_fcCint_826_0_19, (int) ('u'), G__get_linked_tagnum(&G__PamVMC_fcCintLN_GPSSPEData), -1, 1, 1, 1, 1, 0, "u 'GPSSPEData' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncpGPSSPEHits(void) {
   /* pGPSSPEHits */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__PamVMC_fcCintLN_pGPSSPEHits));
   G__memfunc_setup("pGPSSPEHits",986,G__PamVMC_fcCint_827_0_1, 105, G__get_linked_tagnum(&G__PamVMC_fcCintLN_pGPSSPEHits), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Clean",483,G__PamVMC_fcCint_827_0_2, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Clear",487,G__PamVMC_fcCint_827_0_3, 121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Compress",844,G__PamVMC_fcCint_827_0_4, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CreateXHit",977,G__PamVMC_fcCint_827_0_5, 85, G__get_linked_tagnum(&G__PamVMC_fcCintLN_GPSSPEData), -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - flag", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CreateYHit",978,G__PamVMC_fcCint_827_0_6, 85, G__get_linked_tagnum(&G__PamVMC_fcCintLN_GPSSPEData), -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - flag", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetNXHit",747,G__PamVMC_fcCint_827_0_7, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetNYHit",748,G__PamVMC_fcCint_827_0_8, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetXHit",669,G__PamVMC_fcCint_827_0_9, 85, G__get_linked_tagnum(&G__PamVMC_fcCintLN_GPSSPEData), -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - flag", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetYHit",670,G__PamVMC_fcCint_827_0_10, 85, G__get_linked_tagnum(&G__PamVMC_fcCintLN_GPSSPEData), -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - flag", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetData",678,G__PamVMC_fcCint_827_0_11, 121, -1, -1, 0, 1, 1, 1, 0, "U 'cGPSSPE' - 0 - c", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Print",525,G__PamVMC_fcCint_827_0_12, 121, -1, -1, 0, 1, 1, 1, 8, "C - 'Option_t' 10 '\"\"' -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__PamVMC_fcCint_827_0_13, 85, G__get_linked_tagnum(&G__PamVMC_fcCintLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&pGPSSPEHits::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__PamVMC_fcCint_827_0_14, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&pGPSSPEHits::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__PamVMC_fcCint_827_0_15, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&pGPSSPEHits::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__PamVMC_fcCint_827_0_16, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&pGPSSPEHits::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,G__PamVMC_fcCint_827_0_17, 85, G__get_linked_tagnum(&G__PamVMC_fcCintLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,G__PamVMC_fcCint_827_0_18, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,G__PamVMC_fcCint_827_0_19, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__PamVMC_fcCint_827_0_20, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__PamVMC_fcCint_827_0_21, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&pGPSSPEHits::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__PamVMC_fcCint_827_0_22, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&pGPSSPEHits::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__PamVMC_fcCint_827_0_23, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&pGPSSPEHits::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__PamVMC_fcCint_827_0_24, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&pGPSSPEHits::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("pGPSSPEHits", 986, G__PamVMC_fcCint_827_0_25, (int) ('i'), G__get_linked_tagnum(&G__PamVMC_fcCintLN_pGPSSPEHits), -1, 0, 1, 1, 1, 0, "u 'pGPSSPEHits' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~pGPSSPEHits", 1112, G__PamVMC_fcCint_827_0_26, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__PamVMC_fcCint_827_0_27, (int) ('u'), G__get_linked_tagnum(&G__PamVMC_fcCintLN_pGPSSPEHits), -1, 1, 1, 1, 1, 0, "u 'pGPSSPEHits' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncPamVMCTrkDig(void) {
   /* PamVMCTrkDig */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__PamVMC_fcCintLN_PamVMCTrkDig));
   G__memfunc_setup("PamVMCTrkDig",1097,G__PamVMC_fcCint_830_0_1, 105, G__get_linked_tagnum(&G__PamVMC_fcCintLN_PamVMCTrkDig), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("LoadCalib",859,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetRandom",909,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TRandom3' - 0 - random", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetRandomExt",1214,G__PamVMC_fcCint_830_0_4, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TRandom3' - 0 - random", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("RegisterTrkData",1520,G__PamVMC_fcCint_830_0_5, 121, -1, -1, 0, 1, 1, 1, 0, "U 'pGPSSPEHits' - 0 - hits", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Digitize",825,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("PrintCollections",1676,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("LoadFile",768,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("WriteCalib",998,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("LoadMipCor",970,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DigitizeTrackCalib",1801,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "i - 'Int_t' 0 - n", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("BrokenStrip",1139,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 5, 1, 4, 0, 
"i - 'Int_t' 0 - planebr i - 'Int_t' 0 - vabr "
"i - 'Int_t' 0 - plane i - 'Int_t' 0 - strip "
"i - 'Int_t' 1 - goodst", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SaturationTrackx",1687,(G__InterfaceMethod) NULL, 102, -1, G__defined_typename("Float_t"), 0, 1, 1, 4, 0, "f - 'Float_t' 0 - ADC", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SaturationTracky",1688,(G__InterfaceMethod) NULL, 102, -1, G__defined_typename("Float_t"), 0, 1, 1, 4, 0, "f - 'Float_t' 0 - ADC", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CompressTrackData",1723,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__PamVMC_fcCint_830_0_16, 85, G__get_linked_tagnum(&G__PamVMC_fcCintLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&PamVMCTrkDig::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__PamVMC_fcCint_830_0_17, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&PamVMCTrkDig::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__PamVMC_fcCint_830_0_18, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&PamVMCTrkDig::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__PamVMC_fcCint_830_0_19, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&PamVMCTrkDig::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__PamVMC_fcCintLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__PamVMC_fcCint_830_0_23, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__PamVMC_fcCint_830_0_24, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&PamVMCTrkDig::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__PamVMC_fcCint_830_0_25, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&PamVMCTrkDig::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__PamVMC_fcCint_830_0_26, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&PamVMCTrkDig::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__PamVMC_fcCint_830_0_27, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&PamVMCTrkDig::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~PamVMCTrkDig", 1223, G__PamVMC_fcCint_830_0_28, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncPamVMCTofDig(void) {
   /* PamVMCTofDig */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__PamVMC_fcCintLN_PamVMCTofDig));
   G__memfunc_setup("TimeRes",697,(G__InterfaceMethod) NULL, 102, -1, G__defined_typename("Float_t"), 0, 1, 1, 4, 0, "i - 'Int_t' 0 - PrimaryPDG", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DigitizeTofPlane",1618,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 3, 1, 4, 0, 
"i - 'Int_t' 0 - planeNo U 'TClonesArray' - 0 - HitColl "
"i - 'Int_t' 0 - PrimaryPDG", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Paddle2Pmt",941,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 4, 1, 4, 0, 
"i - 'Int_t' 0 - planeNo i - 'Int_t' 0 - padNo "
"I - 'Int_t' 0 - pl I - 'Int_t' 0 - pr", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Bin2GrayTof",1031,(G__InterfaceMethod) NULL, 98, -1, G__defined_typename("UChar_t"), 0, 2, 1, 4, 0, 
"b - 'UChar_t' 0 - binaTOF b - 'UChar_t' 0 - grayTOF", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("EvaluateCrc",1103,(G__InterfaceMethod) NULL, 98, -1, G__defined_typename("UChar_t"), 0, 2, 1, 4, 0, 
"B - 'UChar_t' 0 - pTrg i - 'Int_t' 0 - nb", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Crc8Tof",633,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 2, 1, 4, 0, 
"B - 'UChar_t' 0 - oldCRC B - 'UChar_t' 0 - crcTof", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("PamVMCTofDig",1089,G__PamVMC_fcCint_831_0_7, 105, G__get_linked_tagnum(&G__PamVMC_fcCintLN_PamVMCTofDig), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Digitize",825,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", "not used", (void*) NULL, 1);
   G__memfunc_setup("WriteToBuff",1105,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DigitizeTOF",1058,G__PamVMC_fcCint_831_0_10, 121, -1, -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - EventNo i - 'Int_t' 0 - PrimaryPDG", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("LoadCalib",859,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__PamVMC_fcCint_831_0_12, 85, G__get_linked_tagnum(&G__PamVMC_fcCintLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&PamVMCTofDig::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__PamVMC_fcCint_831_0_13, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&PamVMCTofDig::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__PamVMC_fcCint_831_0_14, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&PamVMCTofDig::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__PamVMC_fcCint_831_0_15, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&PamVMCTofDig::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__PamVMC_fcCintLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__PamVMC_fcCint_831_0_19, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__PamVMC_fcCint_831_0_20, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&PamVMCTofDig::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__PamVMC_fcCint_831_0_21, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&PamVMCTofDig::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__PamVMC_fcCint_831_0_22, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&PamVMCTofDig::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__PamVMC_fcCint_831_0_23, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&PamVMCTofDig::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~PamVMCTofDig", 1215, G__PamVMC_fcCint_831_0_24, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncPamVMCAcDig(void) {
   /* PamVMCAcDig */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__PamVMC_fcCintLN_PamVMCAcDig));
   G__memfunc_setup("FillErel",783,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddErel",657,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 2, 1, 4, 0, 
"U 'TClonesArray' - 0 - HitColl i - 'Int_t' 0 - detcode", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("PamVMCAcDig",956,G__PamVMC_fcCint_845_0_3, 105, G__get_linked_tagnum(&G__PamVMC_fcCintLN_PamVMCAcDig), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Digitize",825,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", "not used", (void*) NULL, 1);
   G__memfunc_setup("DigitizeAC",957,G__PamVMC_fcCint_845_0_5, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - EventNo", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__PamVMC_fcCint_845_0_6, 85, G__get_linked_tagnum(&G__PamVMC_fcCintLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&PamVMCAcDig::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__PamVMC_fcCint_845_0_7, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&PamVMCAcDig::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__PamVMC_fcCint_845_0_8, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&PamVMCAcDig::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__PamVMC_fcCint_845_0_9, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&PamVMCAcDig::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__PamVMC_fcCintLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__PamVMC_fcCint_845_0_13, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__PamVMC_fcCint_845_0_14, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&PamVMCAcDig::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__PamVMC_fcCint_845_0_15, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&PamVMCAcDig::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__PamVMC_fcCint_845_0_16, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&PamVMCAcDig::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__PamVMC_fcCint_845_0_17, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&PamVMCAcDig::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~PamVMCAcDig", 1082, G__PamVMC_fcCint_845_0_18, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncPamVMCCaloDig(void) {
   /* PamVMCCaloDig */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__PamVMC_fcCintLN_PamVMCCaloDig));
   G__memfunc_setup("ClearCaloCalib",1345,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "i - 'Int_t' 0 - s", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CaloLoadCalib",1242,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 3, 1, 4, 0, 
"i - 'Int_t' 0 - s u 'TString' - 0 - calname "
"h - 'UInt_t' 0 - calibno", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DigitizeCALOCALIB",1459,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("FillCalPedNorm",1356,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 2, 1, 4, 0, 
"U 'vector<unsigned short,allocator<unsigned short> >' 'USBuffer' 0 - buff i - 'Int_t' 0 - sec", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("FillCalPedBack",1313,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 2, 1, 4, 0, 
"U 'vector<unsigned short,allocator<unsigned short> >' 'USBuffer' 0 - buff i - 'Int_t' 0 - sec", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("FillCalThrNorm",1377,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 2, 1, 4, 0, 
"U 'vector<unsigned short,allocator<unsigned short> >' 'USBuffer' 0 - buff i - 'Int_t' 0 - sec", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("FillCalThrBack",1334,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 2, 1, 4, 0, 
"U 'vector<unsigned short,allocator<unsigned short> >' 'USBuffer' 0 - buff i - 'Int_t' 0 - sec", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("FillCalRmsNorm",1381,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 2, 1, 4, 0, 
"U 'vector<unsigned short,allocator<unsigned short> >' 'USBuffer' 0 - buff i - 'Int_t' 0 - sec", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("FillCalRmsBack",1338,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 2, 1, 4, 0, 
"U 'vector<unsigned short,allocator<unsigned short> >' 'USBuffer' 0 - buff i - 'Int_t' 0 - sec", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("FillCalBaseVarNorm",1751,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 2, 1, 4, 0, 
"U 'vector<unsigned short,allocator<unsigned short> >' 'USBuffer' 0 - buff i - 'Int_t' 0 - sec", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("FillCalBaseVarBack",1708,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 2, 1, 4, 0, 
"U 'vector<unsigned short,allocator<unsigned short> >' 'USBuffer' 0 - buff i - 'Int_t' 0 - sec", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Incrementevtcalo",1683,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Getevtcalo",1038,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetCaloErel",1063,(G__InterfaceMethod) NULL, 102, -1, G__defined_typename("Float_t"), 0, 3, 1, 4, 0, 
"i - 'Int_t' 0 - sec i - 'Int_t' 0 - plane "
"i - 'Int_t' 0 - strip", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DigitizeCaloRaw",1506,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DigitizeCaloCompress",2052,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DigitizeCaloFull",1611,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("PamVMCCaloDig",1175,G__PamVMC_fcCint_846_0_18, 105, G__get_linked_tagnum(&G__PamVMC_fcCintLN_PamVMCCaloDig), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("LoadCalib",859,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Digitize",825,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__PamVMC_fcCint_846_0_21, 85, G__get_linked_tagnum(&G__PamVMC_fcCintLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&PamVMCCaloDig::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__PamVMC_fcCint_846_0_22, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&PamVMCCaloDig::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__PamVMC_fcCint_846_0_23, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&PamVMCCaloDig::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__PamVMC_fcCint_846_0_24, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&PamVMCCaloDig::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__PamVMC_fcCintLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__PamVMC_fcCint_846_0_28, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__PamVMC_fcCint_846_0_29, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&PamVMCCaloDig::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__PamVMC_fcCint_846_0_30, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&PamVMCCaloDig::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__PamVMC_fcCint_846_0_31, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&PamVMCCaloDig::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__PamVMC_fcCint_846_0_32, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&PamVMCCaloDig::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~PamVMCCaloDig", 1301, G__PamVMC_fcCint_846_0_33, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncPamVMCS4Dig(void) {
   /* PamVMCS4Dig */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__PamVMC_fcCintLN_PamVMCS4Dig));
   G__memfunc_setup("PamVMCS4Dig",927,G__PamVMC_fcCint_847_0_1, 105, G__get_linked_tagnum(&G__PamVMC_fcCintLN_PamVMCS4Dig), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Digitize",825,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__PamVMC_fcCint_847_0_3, 85, G__get_linked_tagnum(&G__PamVMC_fcCintLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&PamVMCS4Dig::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__PamVMC_fcCint_847_0_4, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&PamVMCS4Dig::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__PamVMC_fcCint_847_0_5, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&PamVMCS4Dig::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__PamVMC_fcCint_847_0_6, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&PamVMCS4Dig::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__PamVMC_fcCintLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__PamVMC_fcCint_847_0_10, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__PamVMC_fcCint_847_0_11, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&PamVMCS4Dig::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__PamVMC_fcCint_847_0_12, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&PamVMCS4Dig::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__PamVMC_fcCint_847_0_13, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&PamVMCS4Dig::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__PamVMC_fcCint_847_0_14, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&PamVMCS4Dig::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~PamVMCS4Dig", 1053, G__PamVMC_fcCint_847_0_15, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncPamVMCNDDig(void) {
   /* PamVMCNDDig */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__PamVMC_fcCintLN_PamVMCNDDig));
   G__memfunc_setup("IsInsideVector",1419,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 4, 0, "U 'PamVMCDetectorHit' - 0 - phit", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("PamVMCNDDig",938,G__PamVMC_fcCint_852_0_2, 105, G__get_linked_tagnum(&G__PamVMC_fcCintLN_PamVMCNDDig), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Digitize",825,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__PamVMC_fcCint_852_0_4, 85, G__get_linked_tagnum(&G__PamVMC_fcCintLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&PamVMCNDDig::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__PamVMC_fcCint_852_0_5, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&PamVMCNDDig::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__PamVMC_fcCint_852_0_6, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&PamVMCNDDig::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__PamVMC_fcCint_852_0_7, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&PamVMCNDDig::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__PamVMC_fcCintLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__PamVMC_fcCint_852_0_11, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__PamVMC_fcCint_852_0_12, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&PamVMCNDDig::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__PamVMC_fcCint_852_0_13, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&PamVMCNDDig::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__PamVMC_fcCint_852_0_14, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&PamVMCNDDig::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__PamVMC_fcCint_852_0_15, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&PamVMCNDDig::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~PamVMCNDDig", 1064, G__PamVMC_fcCint_852_0_16, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncPamVMCParticle(void) {
   /* PamVMCParticle */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__PamVMC_fcCintLN_PamVMCParticle));
   G__memfunc_setup("PamVMCParticle",1336,G__PamVMC_fcCint_854_0_1, 105, G__get_linked_tagnum(&G__PamVMC_fcCintLN_PamVMCParticle), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("PamVMCParticle",1336,G__PamVMC_fcCint_854_0_2, 105, G__get_linked_tagnum(&G__PamVMC_fcCintLN_PamVMCParticle), -1, 0, 14, 1, 1, 0, 
"i - 'Int_t' 0 - pdg i - 'Int_t' 0 - status "
"i - 'Int_t' 0 - mother1 i - 'Int_t' 0 - mother2 "
"i - 'Int_t' 0 - daughter1 i - 'Int_t' 0 - daughter2 "
"d - 'Double_t' 0 - px d - 'Double_t' 0 - py "
"d - 'Double_t' 0 - pz d - 'Double_t' 0 - etot "
"d - 'Double_t' 0 - vx d - 'Double_t' 0 - vy "
"d - 'Double_t' 0 - vz d - 'Double_t' 0 - time", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Clear",487,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__PamVMC_fcCint_854_0_4, 85, G__get_linked_tagnum(&G__PamVMC_fcCintLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&PamVMCParticle::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__PamVMC_fcCint_854_0_5, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&PamVMCParticle::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__PamVMC_fcCint_854_0_6, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&PamVMCParticle::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__PamVMC_fcCint_854_0_7, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&PamVMCParticle::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__PamVMC_fcCintLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__PamVMC_fcCint_854_0_11, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__PamVMC_fcCint_854_0_12, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&PamVMCParticle::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__PamVMC_fcCint_854_0_13, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&PamVMCParticle::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__PamVMC_fcCint_854_0_14, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&PamVMCParticle::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__PamVMC_fcCint_854_0_15, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&PamVMCParticle::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("PamVMCParticle", 1336, G__PamVMC_fcCint_854_0_16, (int) ('i'), G__get_linked_tagnum(&G__PamVMC_fcCintLN_PamVMCParticle), -1, 0, 1, 1, 1, 0, "u 'PamVMCParticle' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~PamVMCParticle", 1462, G__PamVMC_fcCint_854_0_17, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__PamVMC_fcCint_854_0_18, (int) ('u'), G__get_linked_tagnum(&G__PamVMC_fcCintLN_PamVMCParticle), -1, 1, 1, 1, 1, 0, "u 'PamVMCParticle' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncPamVMCStack(void) {
   /* PamVMCStack */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__PamVMC_fcCintLN_PamVMCStack));
   G__memfunc_setup("PamVMCStack",1018,G__PamVMC_fcCint_884_0_1, 105, G__get_linked_tagnum(&G__PamVMC_fcCintLN_PamVMCStack), -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - size", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("PamVMCStack",1018,G__PamVMC_fcCint_884_0_2, 105, G__get_linked_tagnum(&G__PamVMC_fcCintLN_PamVMCStack), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("PushTrack",917,(G__InterfaceMethod) NULL,121, -1, -1, 0, 18, 1, 1, 0, 
"i - 'Int_t' 0 - toBeDone i - 'Int_t' 0 - parent "
"i - 'Int_t' 0 - pdg d - 'Double_t' 0 - px "
"d - 'Double_t' 0 - py d - 'Double_t' 0 - pz "
"d - 'Double_t' 0 - e d - 'Double_t' 0 - vx "
"d - 'Double_t' 0 - vy d - 'Double_t' 0 - vz "
"d - 'Double_t' 0 - tof d - 'Double_t' 0 - polx "
"d - 'Double_t' 0 - poly d - 'Double_t' 0 - polz "
"i 'TMCProcess' - 0 - mech i - 'Int_t' 1 - ntr "
"d - 'Double_t' 0 - weight i - 'Int_t' 0 - is", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("PopNextTrack",1219,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__PamVMC_fcCintLN_PamVMCParticle), -1, 0, 1, 1, 1, 0, "i - 'Int_t' 1 - track", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("PopPrimaryForTracking",2157,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__PamVMC_fcCintLN_PamVMCParticle), -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Print",525,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Reset",515,G__PamVMC_fcCint_884_0_7, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetCurrentTrack",1540,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - track", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetNtrack",899,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetNprimary",1138,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetCurrentTrack",1528,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__PamVMC_fcCintLN_PamVMCParticle), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetCurrentTrackNumber",2145,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetCurrentParentTrackNumber",2763,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetParticle",1108,G__PamVMC_fcCint_884_0_14, 85, G__get_linked_tagnum(&G__PamVMC_fcCintLN_PamVMCParticle), -1, 0, 1, 1, 1, 8, "i - 'Int_t' 0 - id", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__PamVMC_fcCint_884_0_15, 85, G__get_linked_tagnum(&G__PamVMC_fcCintLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&PamVMCStack::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__PamVMC_fcCint_884_0_16, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&PamVMCStack::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__PamVMC_fcCint_884_0_17, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&PamVMCStack::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__PamVMC_fcCint_884_0_18, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&PamVMCStack::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__PamVMC_fcCintLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__PamVMC_fcCint_884_0_22, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__PamVMC_fcCint_884_0_23, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&PamVMCStack::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__PamVMC_fcCint_884_0_24, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&PamVMCStack::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__PamVMC_fcCint_884_0_25, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&PamVMCStack::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__PamVMC_fcCint_884_0_26, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&PamVMCStack::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("PamVMCStack", 1018, G__PamVMC_fcCint_884_0_27, (int) ('i'), G__get_linked_tagnum(&G__PamVMC_fcCintLN_PamVMCStack), -1, 0, 1, 1, 1, 0, "u 'PamVMCStack' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~PamVMCStack", 1144, G__PamVMC_fcCint_884_0_28, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__PamVMC_fcCint_884_0_29, (int) ('u'), G__get_linked_tagnum(&G__PamVMC_fcCintLN_PamVMCStack), -1, 1, 1, 1, 1, 0, "u 'PamVMCStack' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncPamVMCDetectorSD(void) {
   /* PamVMCDetectorSD */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__PamVMC_fcCintLN_PamVMCDetectorSD));
   G__memfunc_setup("PamVMCDetectorSD",1493,G__PamVMC_fcCint_891_0_1, 105, G__get_linked_tagnum(&G__PamVMC_fcCintLN_PamVMCDetectorSD), -1, 0, 3, 1, 1, 0, 
"C - - 10 '\"PamVMCDetectorHit\"' cname C - - 10 '\"\"' dname "
"i - 'Int_t' 0 '0' is", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Register",837,G__PamVMC_fcCint_891_0_2, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("AddGeoID",689,G__PamVMC_fcCint_891_0_3, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - dname", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CleanHit",776,G__PamVMC_fcCint_891_0_4, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("InitHit",697,G__PamVMC_fcCint_891_0_5, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("UpdateHit",904,G__PamVMC_fcCint_891_0_6, 121, -1, -1, 0, 2, 1, 1, 0, 
"U 'TVirtualMC' - 0 - g g - 'Bool_t' 0 - is_prim", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SaveHit",692,G__PamVMC_fcCint_891_0_7, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SaveHit",692,G__PamVMC_fcCint_891_0_8, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - f", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SaveHit",692,G__PamVMC_fcCint_891_0_9, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - dname", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("CreateHit",889,G__PamVMC_fcCint_891_0_10, 85, G__get_linked_tagnum(&G__PamVMC_fcCintLN_PamVMCDetectorHit), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("FillVolID",837,G__PamVMC_fcCint_891_0_11, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("CreateHit",889,G__PamVMC_fcCint_891_0_12, 85, G__get_linked_tagnum(&G__PamVMC_fcCintLN_PamVMCDetectorHit), -1, 0, 1, 1, 1, 0, "C - - 10 - dname", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("CreateHit",889,G__PamVMC_fcCint_891_0_13, 85, G__get_linked_tagnum(&G__PamVMC_fcCintLN_PamVMCDetectorHit), -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - flag", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("PreEvent",809,G__PamVMC_fcCint_891_0_14, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Compress",844,G__PamVMC_fcCint_891_0_15, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Digitize",825,G__PamVMC_fcCint_891_0_16, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ClearHitColl",1174,G__PamVMC_fcCint_891_0_17, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("FillHit",684,G__PamVMC_fcCint_891_0_18, 121, -1, -1, 0, 3, 1, 1, 0, 
"i 'fin' - 0 - f U 'TVirtualMC' - 0 - g "
"g - 'Bool_t' 0 - is_prim", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetNhits",806,G__PamVMC_fcCint_891_0_19, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Print",525,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "C - 'Option_t' 10 '\"\"' -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__PamVMC_fcCint_891_0_21, 85, G__get_linked_tagnum(&G__PamVMC_fcCintLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&PamVMCDetectorSD::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__PamVMC_fcCint_891_0_22, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&PamVMCDetectorSD::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__PamVMC_fcCint_891_0_23, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&PamVMCDetectorSD::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__PamVMC_fcCint_891_0_24, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&PamVMCDetectorSD::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__PamVMC_fcCintLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__PamVMC_fcCint_891_0_28, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__PamVMC_fcCint_891_0_29, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&PamVMCDetectorSD::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__PamVMC_fcCint_891_0_30, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&PamVMCDetectorSD::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__PamVMC_fcCint_891_0_31, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&PamVMCDetectorSD::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__PamVMC_fcCint_891_0_32, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&PamVMCDetectorSD::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~PamVMCDetectorSD", 1619, G__PamVMC_fcCint_891_0_33, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncPamVMCPrimary(void) {
   /* PamVMCPrimary */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__PamVMC_fcCintLN_PamVMCPrimary));
   G__memfunc_setup("PamVMCPrimary",1256,G__PamVMC_fcCint_1067_0_1, 105, G__get_linked_tagnum(&G__PamVMC_fcCintLN_PamVMCPrimary), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Clean",483,G__PamVMC_fcCint_1067_0_2, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Clear",487,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Print",525,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "C - 'Option_t' 10 '\"\"' -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__PamVMC_fcCint_1067_0_5, 85, G__get_linked_tagnum(&G__PamVMC_fcCintLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&PamVMCPrimary::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__PamVMC_fcCint_1067_0_6, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&PamVMCPrimary::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__PamVMC_fcCint_1067_0_7, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&PamVMCPrimary::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__PamVMC_fcCint_1067_0_8, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&PamVMCPrimary::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__PamVMC_fcCintLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__PamVMC_fcCint_1067_0_12, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__PamVMC_fcCint_1067_0_13, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&PamVMCPrimary::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__PamVMC_fcCint_1067_0_14, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&PamVMCPrimary::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__PamVMC_fcCint_1067_0_15, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&PamVMCPrimary::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__PamVMC_fcCint_1067_0_16, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&PamVMCPrimary::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("PamVMCPrimary", 1256, G__PamVMC_fcCint_1067_0_17, (int) ('i'), G__get_linked_tagnum(&G__PamVMC_fcCintLN_PamVMCPrimary), -1, 0, 1, 1, 1, 0, "u 'PamVMCPrimary' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~PamVMCPrimary", 1382, G__PamVMC_fcCint_1067_0_18, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__PamVMC_fcCint_1067_0_19, (int) ('u'), G__get_linked_tagnum(&G__PamVMC_fcCintLN_PamVMCPrimary), -1, 1, 1, 1, 1, 0, "u 'PamVMCPrimary' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncPamVMCPrimaryGenerator(void) {
   /* PamVMCPrimaryGenerator */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__PamVMC_fcCintLN_PamVMCPrimaryGenerator));
   G__memfunc_setup("PamVMCPrimaryGenerator",2191,G__PamVMC_fcCint_1068_0_1, 105, G__get_linked_tagnum(&G__PamVMC_fcCintLN_PamVMCPrimaryGenerator), -1, 0, 1, 1, 1, 0, "U 'TVirtualMCStack' - 0 - stack", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("PamVMCPrimaryGenerator",2191,G__PamVMC_fcCint_1068_0_2, 105, G__get_linked_tagnum(&G__PamVMC_fcCintLN_PamVMCPrimaryGenerator), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GeneratePrimary",1551,G__PamVMC_fcCint_1068_0_3, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetParticle",1120,G__PamVMC_fcCint_1068_0_4, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - pdg", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetParticleID",1261,G__PamVMC_fcCint_1068_0_5, 121, -1, -1, 0, 1, 1, 1, 0, "h - 'UInt_t' 0 - id", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetPosition",1153,G__PamVMC_fcCint_1068_0_6, 121, -1, -1, 0, 3, 1, 1, 0, 
"d - 'Double_t' 0 - vx d - 'Double_t' 0 - vy "
"d - 'Double_t' 0 - vz", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetKinEnergy",1208,G__PamVMC_fcCint_1068_0_7, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - kinEnergy", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetRigidity",1137,G__PamVMC_fcCint_1068_0_8, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - rigidity", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetMomentum",1150,G__PamVMC_fcCint_1068_0_9, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - momentum", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetDirection",1229,G__PamVMC_fcCint_1068_0_10, 121, -1, -1, 0, 2, 1, 1, 0, 
"d - 'Double_t' 0 - theta d - 'Double_t' 0 - phi", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetMomentum",1150,G__PamVMC_fcCint_1068_0_11, 121, -1, -1, 0, 3, 1, 1, 0, 
"d - 'Double_t' 0 - px d - 'Double_t' 0 - py "
"d - 'Double_t' 0 - pz", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GenPosition",1135,G__PamVMC_fcCint_1068_0_12, 121, -1, -1, 0, 6, 1, 1, 0, 
"d - 'Double_t' 0 - xmin d - 'Double_t' 0 - xmax "
"d - 'Double_t' 0 - ymin d - 'Double_t' 0 - ymax "
"d - 'Double_t' 0 - zmin d - 'Double_t' 0 - zmax", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GenDirection",1211,G__PamVMC_fcCint_1068_0_13, 121, -1, -1, 0, 4, 1, 1, 0, 
"d - 'Double_t' 0 - thetamin d - 'Double_t' 0 - thetamax "
"d - 'Double_t' 0 - phimin d - 'Double_t' 0 - phimax", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GenPosAng",866,G__PamVMC_fcCint_1068_0_14, 121, -1, -1, 0, 2, 1, 1, 0, 
"u 'TVector3' - 1 - pos u 'TVector2' - 1 - ang", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Gen2PiPosAng",1101,G__PamVMC_fcCint_1068_0_15, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ExtrapolateTrajectory",2224,G__PamVMC_fcCint_1068_0_16, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ToBeSimulated",1298,G__PamVMC_fcCint_1068_0_17, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GenSpe",578,G__PamVMC_fcCint_1068_0_18, 121, -1, -1, 0, 3, 1, 1, 0, 
"d - 'Double_t' 0 - PEmin d - 'Double_t' 0 - PEmax "
"g - 'Bool_t' 0 'kFALSE' isEnergy", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GenSpe",578,G__PamVMC_fcCint_1068_0_19, 121, -1, -1, 0, 4, 1, 1, 0, 
"d - 'Double_t' 0 - PEmin d - 'Double_t' 0 - PEmax "
"d - 'Double_t' 0 - gamma g - 'Bool_t' 0 'kFALSE' isEnergy", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GenSpe_Flat",1064,G__PamVMC_fcCint_1068_0_20, 121, -1, -1, 0, 4, 1, 1, 0, 
"d - 'Double_t' 0 - PEmin d - 'Double_t' 0 - PEmax "
"d - 'Double_t' 0 - gamma g - 'Bool_t' 0 'kFALSE' isEnergy", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GenSpe_3par",1047,G__PamVMC_fcCint_1068_0_21, 121, -1, -1, 0, 5, 1, 1, 0, 
"d - 'Double_t' 0 - PEmin d - 'Double_t' 0 - PEmax "
"d - 'Double_t' 0 - a d - 'Double_t' 0 - b "
"d - 'Double_t' 0 - c", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GenSphericalPhiThe",1783,G__PamVMC_fcCint_1068_0_22, 121, -1, -1, 0, 0, 1, 1, 0, "", "cecilia // flusso istropo // sets phi the", (void*) NULL, 0);
   G__memfunc_setup("GenSphPhiThe",1159,G__PamVMC_fcCint_1068_0_23, 121, -1, -1, 0, 6, 1, 1, 0, 
"d - 'Double_t' 0 - xmin d - 'Double_t' 0 - xmax "
"d - 'Double_t' 0 - ymin d - 'Double_t' 0 - ymax "
"d - 'Double_t' 0 - zmin d - 'Double_t' 0 - zmax", "flusso isotropo entro S2 S3", (void*) NULL, 0);
   G__memfunc_setup("GetParticleID",1249,G__PamVMC_fcCint_1068_0_24, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetParticle",1108,G__PamVMC_fcCint_1068_0_25, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetPositon",1036,G__PamVMC_fcCint_1068_0_26, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TVector3' - 1 - v", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetPosition",1141,G__PamVMC_fcCint_1068_0_27, 121, -1, -1, 0, 3, 1, 1, 0, 
"d - 'Double_t' 1 - X0 d - 'Double_t' 1 - Y0 "
"d - 'Double_t' 1 - Z0", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetKinEnergy",1196,G__PamVMC_fcCint_1068_0_28, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetRigidity",1125,G__PamVMC_fcCint_1068_0_29, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMomentum",1138,G__PamVMC_fcCint_1068_0_30, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Get2PiArea",900,G__PamVMC_fcCint_1068_0_31, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetDirection",1217,G__PamVMC_fcCint_1068_0_32, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TVector2' - 1 - v", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetDirection",1217,G__PamVMC_fcCint_1068_0_33, 121, -1, -1, 0, 2, 1, 1, 0, 
"d - 'Double_t' 1 - theta d - 'Double_t' 1 - phi", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Getgood",713,G__PamVMC_fcCint_1068_0_34, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetTol",591,G__PamVMC_fcCint_1068_0_35, 121, -1, -1, 0, 2, 1, 1, 0, 
"d - 'Double_t' 1 - xtol d - 'Double_t' 1 - ytol", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetCR_GF",673,G__PamVMC_fcCint_1068_0_36, 121, -1, -1, 0, 3, 1, 1, 0, 
"d - 'Double_t' 1 - xcr d - 'Double_t' 1 - ycr "
"i - 'Int_t' 0 - id_GF", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetNgood",791,G__PamVMC_fcCint_1068_0_37, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetRandom",909,G__PamVMC_fcCint_1068_0_38, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TRandom' - 0 - random", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Register",837,G__PamVMC_fcCint_1068_0_39, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ClearPrimCol",1181,G__PamVMC_fcCint_1068_0_40, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetZeroStep",1128,G__PamVMC_fcCint_1068_0_41, 121, -1, -1, 0, 3, 1, 1, 0, 
"d - 'Double_t' 0 - z_curr d - 'Double_t' 0 - x_curr "
"d - 'Double_t' 0 - y_curr", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CheckCrossing",1318,G__PamVMC_fcCint_1068_0_42, 121, -1, -1, 0, 3, 1, 1, 0, 
"d - 'Double_t' 0 - z_curr d - 'Double_t' 0 - x_curr "
"d - 'Double_t' 0 - y_curr", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CheckInsideAcceptance",2081,G__PamVMC_fcCint_1068_0_43, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MomentumToKinE",1404,G__PamVMC_fcCint_1068_0_44, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 0, "d - 'Double_t' 0 - P0", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("KinEToMomentum",1404,G__PamVMC_fcCint_1068_0_45, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 0, "d - 'Double_t' 0 - E0", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MomentumToRig",1335,G__PamVMC_fcCint_1068_0_46, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 0, "d - 'Double_t' 0 - P0", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("RigToMomentum",1335,G__PamVMC_fcCint_1068_0_47, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 0, "d - 'Double_t' 0 - R0", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("function3par",1244,G__PamVMC_fcCint_1068_0_48, 100, -1, G__defined_typename("Double_t"), 0, 4, 1, 1, 0, 
"d - 'Double_t' 0 - xx d - 'Double_t' 0 - a "
"d - 'Double_t' 0 - b d - 'Double_t' 0 - c", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__PamVMC_fcCint_1068_0_49, 85, G__get_linked_tagnum(&G__PamVMC_fcCintLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&PamVMCPrimaryGenerator::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__PamVMC_fcCint_1068_0_50, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&PamVMCPrimaryGenerator::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__PamVMC_fcCint_1068_0_51, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&PamVMCPrimaryGenerator::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__PamVMC_fcCint_1068_0_52, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&PamVMCPrimaryGenerator::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__PamVMC_fcCintLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__PamVMC_fcCint_1068_0_56, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__PamVMC_fcCint_1068_0_57, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&PamVMCPrimaryGenerator::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__PamVMC_fcCint_1068_0_58, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&PamVMCPrimaryGenerator::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__PamVMC_fcCint_1068_0_59, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&PamVMCPrimaryGenerator::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__PamVMC_fcCint_1068_0_60, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&PamVMCPrimaryGenerator::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("PamVMCPrimaryGenerator", 2191, G__PamVMC_fcCint_1068_0_61, (int) ('i'), 
G__get_linked_tagnum(&G__PamVMC_fcCintLN_PamVMCPrimaryGenerator), -1, 0, 1, 1, 1, 0, "u 'PamVMCPrimaryGenerator' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~PamVMCPrimaryGenerator", 2317, G__PamVMC_fcCint_1068_0_62, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__PamVMC_fcCint_1068_0_63, (int) ('u'), G__get_linked_tagnum(&G__PamVMC_fcCintLN_PamVMCPrimaryGenerator), -1, 1, 1, 1, 1, 0, "u 'PamVMCPrimaryGenerator' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncpCutControl(void) {
   /* pCutControl */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__PamVMC_fcCintLN_pCutControl));
   G__memfunc_setup("pCutControl",1149,G__PamVMC_fcCint_1163_0_1, 105, G__get_linked_tagnum(&G__PamVMC_fcCintLN_pCutControl), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("pCutControl",1149,G__PamVMC_fcCint_1163_0_2, 105, G__get_linked_tagnum(&G__PamVMC_fcCintLN_pCutControl), -1, 0, 23, 1, 1, 0, 
"i - 'Int_t' 0 - id d - 'Double_t' 0 - CUTGAM "
"d - 'Double_t' 0 - BCUTE d - 'Double_t' 0 - CUTELE "
"d - 'Double_t' 0 - DCUTE d - 'Double_t' 0 - CUTNEU "
"d - 'Double_t' 0 - CUTHAD d - 'Double_t' 0 - CUTMUO "
"d - 'Double_t' 0 - DCUTM d - 'Double_t' 0 - BCUTM "
"d - 'Double_t' 0 - PPCUTM d - 'Double_t' 0 - PAIR "
"d - 'Double_t' 0 - COMP d - 'Double_t' 0 - PHOT "
"d - 'Double_t' 0 - PFIS d - 'Double_t' 0 - DRAY "
"d - 'Double_t' 0 - ANNI d - 'Double_t' 0 - BREM "
"d - 'Double_t' 0 - HADR d - 'Double_t' 0 - MUNU "
"d - 'Double_t' 0 - DCAY d - 'Double_t' 0 - LOSS "
"d - 'Double_t' 0 - MULS", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetID",429,G__PamVMC_fcCint_1163_0_3, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetCUTGAM",737,G__PamVMC_fcCint_1163_0_4, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetBCUTE",659,G__PamVMC_fcCint_1163_0_5, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetCUTELE",738,G__PamVMC_fcCint_1163_0_6, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetDCUTE",661,G__PamVMC_fcCint_1163_0_7, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetCUTNEU",756,G__PamVMC_fcCint_1163_0_8, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetCUTHAD",729,G__PamVMC_fcCint_1163_0_9, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetCUTMUO",765,G__PamVMC_fcCint_1163_0_10, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetDCUTM",669,G__PamVMC_fcCint_1163_0_11, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetBCUTM",667,G__PamVMC_fcCint_1163_0_12, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetPPCUTM",761,G__PamVMC_fcCint_1163_0_13, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetPAIR",588,G__PamVMC_fcCint_1163_0_14, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetCOMP",591,G__PamVMC_fcCint_1163_0_15, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetPHOT",603,G__PamVMC_fcCint_1163_0_16, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetPFIS",594,G__PamVMC_fcCint_1163_0_17, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetDRAY",592,G__PamVMC_fcCint_1163_0_18, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetANNI",582,G__PamVMC_fcCint_1163_0_19, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetBREM",582,G__PamVMC_fcCint_1163_0_20, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetHADR",575,G__PamVMC_fcCint_1163_0_21, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMUNU",613,G__PamVMC_fcCint_1163_0_22, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetDCAY",577,G__PamVMC_fcCint_1163_0_23, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetLOSS",609,G__PamVMC_fcCint_1163_0_24, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMULS",609,G__PamVMC_fcCint_1163_0_25, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetID",441,G__PamVMC_fcCint_1163_0_26, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - id", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetCUTGAM",749,G__PamVMC_fcCint_1163_0_27, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - CUTGAM", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetBCUTE",671,G__PamVMC_fcCint_1163_0_28, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - BCUTE", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetCUTELE",750,G__PamVMC_fcCint_1163_0_29, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - CUTELE", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetDCUTE",673,G__PamVMC_fcCint_1163_0_30, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - DCUTE", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetCUTNEU",768,G__PamVMC_fcCint_1163_0_31, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - CUTNEU", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetCUTHAD",741,G__PamVMC_fcCint_1163_0_32, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - CUTHAD", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetCUTMUO",777,G__PamVMC_fcCint_1163_0_33, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - CUTMUO", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetDCUTM",681,G__PamVMC_fcCint_1163_0_34, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - DCUTM", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetBCUTM",679,G__PamVMC_fcCint_1163_0_35, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - BCUTM", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetPPCUTM",773,G__PamVMC_fcCint_1163_0_36, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - PPCUTM", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetPAIR",600,G__PamVMC_fcCint_1163_0_37, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - PAIR", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetCOMP",603,G__PamVMC_fcCint_1163_0_38, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - COMP", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetPHOT",615,G__PamVMC_fcCint_1163_0_39, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - PHOT", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetPFIS",606,G__PamVMC_fcCint_1163_0_40, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - PFIS", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetDRAY",604,G__PamVMC_fcCint_1163_0_41, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - DRAY", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetANNI",594,G__PamVMC_fcCint_1163_0_42, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - ANNI", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetBREM",594,G__PamVMC_fcCint_1163_0_43, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - BREM", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetHADR",587,G__PamVMC_fcCint_1163_0_44, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - HADR", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetMUNU",625,G__PamVMC_fcCint_1163_0_45, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - MUNU", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetDCAY",589,G__PamVMC_fcCint_1163_0_46, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - DCAY", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetLOSS",621,G__PamVMC_fcCint_1163_0_47, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - LOSS", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetMULS",621,G__PamVMC_fcCint_1163_0_48, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - MULS", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("FindMedia",865,G__PamVMC_fcCint_1163_0_49, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetCuts",715,G__PamVMC_fcCint_1163_0_50, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Print",525,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "C - 'Option_t' 10 '\"\"' -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__PamVMC_fcCint_1163_0_52, 85, G__get_linked_tagnum(&G__PamVMC_fcCintLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&pCutControl::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__PamVMC_fcCint_1163_0_53, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&pCutControl::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__PamVMC_fcCint_1163_0_54, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&pCutControl::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__PamVMC_fcCint_1163_0_55, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&pCutControl::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__PamVMC_fcCintLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__PamVMC_fcCint_1163_0_59, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__PamVMC_fcCint_1163_0_60, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&pCutControl::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__PamVMC_fcCint_1163_0_61, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&pCutControl::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__PamVMC_fcCint_1163_0_62, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&pCutControl::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__PamVMC_fcCint_1163_0_63, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&pCutControl::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("pCutControl", 1149, G__PamVMC_fcCint_1163_0_64, (int) ('i'), G__get_linked_tagnum(&G__PamVMC_fcCintLN_pCutControl), -1, 0, 1, 1, 1, 0, "u 'pCutControl' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~pCutControl", 1275, G__PamVMC_fcCint_1163_0_65, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__PamVMC_fcCint_1163_0_66, (int) ('u'), G__get_linked_tagnum(&G__PamVMC_fcCintLN_pCutControl), -1, 1, 1, 1, 1, 0, "u 'pCutControl' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncPamVMCDetGeom(void) {
   /* PamVMCDetGeom */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__PamVMC_fcCintLN_PamVMCDetGeom));
   G__memfunc_setup("PamVMCDetGeom",1193,G__PamVMC_fcCint_1170_0_1, 105, G__get_linked_tagnum(&G__PamVMC_fcCintLN_PamVMCDetGeom), -1, 0, 1, 1, 1, 0, "C - - 10 '\"NoDetGeom\"' dname", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetRot",597,G__PamVMC_fcCint_1170_0_2, 85, G__get_linked_tagnum(&G__PamVMC_fcCintLN_TGeoRotation), -1, 0, 1, 1, 1, 0, "C - - 10 - rot", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMedID",707,G__PamVMC_fcCint_1170_0_3, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "C - - 10 - name", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMat",578,G__PamVMC_fcCint_1170_0_4, 85, G__get_linked_tagnum(&G__PamVMC_fcCintLN_TGeoMaterial), -1, 0, 1, 1, 1, 0, "C - - 10 - name", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMed",566,G__PamVMC_fcCint_1170_0_5, 85, G__get_linked_tagnum(&G__PamVMC_fcCintLN_TGeoMedium), -1, 0, 1, 1, 1, 0, "C - - 10 - name", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetVol",593,G__PamVMC_fcCint_1170_0_6, 85, G__get_linked_tagnum(&G__PamVMC_fcCintLN_TGeoVolume), -1, 0, 1, 1, 1, 0, "C - - 10 - name", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CheckDef",749,G__PamVMC_fcCint_1170_0_7, 85, G__get_linked_tagnum(&G__PamVMC_fcCintLN_TObject), -1, 0, 2, 1, 1, 0, 
"C - - 10 - name i 'PamVMCDetGeom::kind' - 0 - k", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddMotherProp",1305,G__PamVMC_fcCint_1170_0_8, 121, -1, -1, 0, 1, 1, 1, 0, "U 'pMotherProp' - 0 - mp", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddMotherProp",1305,G__PamVMC_fcCint_1170_0_9, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TObjArray' - 0 - mp", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetMotherProp",1340,G__PamVMC_fcCint_1170_0_10, 121, -1, -1, 0, 1, 1, 1, 0, "U 'pMotherProp' - 0 - mp", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetMotherProp",1340,G__PamVMC_fcCint_1170_0_11, 121, -1, -1, 0, 3, 1, 1, 0, 
"U 'TGeoVolume' - 0 - mv i - 'Int_t' 0 - cn "
"U 'TGeoMatrix' - 0 - mx", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetMotherVol",1228,G__PamVMC_fcCint_1170_0_12, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TGeoVolume' - 0 - mv", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMotherProp",1328,G__PamVMC_fcCint_1170_0_13, 85, G__get_linked_tagnum(&G__PamVMC_fcCintLN_TObjArray), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("RegisterNodes",1342,G__PamVMC_fcCint_1170_0_14, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("RegisterNodes",1342,G__PamVMC_fcCint_1170_0_15, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TObjArray' - 0 - to", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__PamVMC_fcCint_1170_0_16, 85, G__get_linked_tagnum(&G__PamVMC_fcCintLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&PamVMCDetGeom::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__PamVMC_fcCint_1170_0_17, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&PamVMCDetGeom::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__PamVMC_fcCint_1170_0_18, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&PamVMCDetGeom::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__PamVMC_fcCint_1170_0_19, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&PamVMCDetGeom::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__PamVMC_fcCintLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__PamVMC_fcCint_1170_0_23, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__PamVMC_fcCint_1170_0_24, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&PamVMCDetGeom::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__PamVMC_fcCint_1170_0_25, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&PamVMCDetGeom::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__PamVMC_fcCint_1170_0_26, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&PamVMCDetGeom::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__PamVMC_fcCint_1170_0_27, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&PamVMCDetGeom::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~PamVMCDetGeom", 1319, G__PamVMC_fcCint_1170_0_28, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncPamVMCDetector(void) {
   /* PamVMCDetector */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__PamVMC_fcCintLN_PamVMCDetector));
   G__memfunc_setup("DefineGeometry",1431,G__PamVMC_fcCint_1173_0_2, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("DefineCuts",1002,G__PamVMC_fcCint_1173_0_3, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("SetCuts",715,G__PamVMC_fcCint_1173_0_4, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ConstructGeometry",1809,G__PamVMC_fcCint_1173_0_5, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ConstructCuts",1380,G__PamVMC_fcCint_1173_0_6, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("InitGeometry",1248,G__PamVMC_fcCint_1173_0_7, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetMotherVol",1216,G__PamVMC_fcCint_1173_0_8, 85, G__get_linked_tagnum(&G__PamVMC_fcCintLN_TGeoVolume), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("InitMC",548,G__PamVMC_fcCint_1173_0_9, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetRot",597,G__PamVMC_fcCint_1173_0_10, 85, G__get_linked_tagnum(&G__PamVMC_fcCintLN_TGeoRotation), -1, 0, 1, 1, 1, 0, "C - - 10 - name", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddRot",574,G__PamVMC_fcCint_1173_0_11, 121, -1, -1, 0, 2, 1, 1, 0, 
"C - - 10 - name U 'TGeoRotation' - 0 - rot", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddMotherProp",1305,G__PamVMC_fcCint_1173_0_12, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TObjArray' - 0 - mp", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddMotherProp",1305,G__PamVMC_fcCint_1173_0_13, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetMotherProp",1340,G__PamVMC_fcCint_1173_0_14, 121, -1, -1, 0, 3, 1, 1, 0, 
"U 'TGeoVolume' - 0 - mv i - 'Int_t' 0 - cn "
"U 'TGeoMatrix' - 0 - mx", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetCC",434,G__PamVMC_fcCint_1173_0_15, 121, -1, -1, 0, 2, 1, 1, 0, 
"C - - 10 - medname U 'pCutControl' - 0 - pCC", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetCC",422,G__PamVMC_fcCint_1173_0_16, 85, G__get_linked_tagnum(&G__PamVMC_fcCintLN_pCutControl), -1, 0, 1, 1, 1, 0, "C - - 10 - medname", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMotherProp",1328,G__PamVMC_fcCint_1173_0_17, 85, G__get_linked_tagnum(&G__PamVMC_fcCintLN_TObjArray), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetMotherVol",1228,G__PamVMC_fcCint_1173_0_18, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TGeoVolume' - 0 - mv", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("RegisterNodes",1342,G__PamVMC_fcCint_1173_0_19, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMedID",707,G__PamVMC_fcCint_1173_0_20, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "C - - 10 - name", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMat",578,G__PamVMC_fcCint_1173_0_21, 85, G__get_linked_tagnum(&G__PamVMC_fcCintLN_TGeoMaterial), -1, 0, 1, 1, 1, 0, "C - - 10 - name", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMed",566,G__PamVMC_fcCint_1173_0_22, 85, G__get_linked_tagnum(&G__PamVMC_fcCintLN_TGeoMedium), -1, 0, 1, 1, 1, 0, "C - - 10 - name", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetVol",593,G__PamVMC_fcCint_1173_0_23, 85, G__get_linked_tagnum(&G__PamVMC_fcCintLN_TGeoVolume), -1, 0, 1, 1, 1, 0, "C - - 10 - name", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("PrintMediumCuts",1549,G__PamVMC_fcCint_1173_0_24, 121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Print",525,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "C - 'Option_t' 10 '\"\"' -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("PrintColl",919,G__PamVMC_fcCint_1173_0_26, 121, -1, -1, 0, 3, 1, 1, 8, 
"U 'TMap' - 10 - tm C - - 10 '\" HIT COLLECTIONS: \"' label "
"C - 'Option_t' 10 '\"\"' -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("PrintHitColl",1212,G__PamVMC_fcCint_1173_0_27, 121, -1, -1, 0, 1, 1, 1, 8, "C - 'Option_t' 10 '\"\"' -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("PrintGeoColl",1202,G__PamVMC_fcCint_1173_0_28, 121, -1, -1, 0, 1, 1, 1, 8, "C - 'Option_t' 10 '\"\"' -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__PamVMC_fcCint_1173_0_29, 85, G__get_linked_tagnum(&G__PamVMC_fcCintLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&PamVMCDetector::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__PamVMC_fcCint_1173_0_30, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&PamVMCDetector::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__PamVMC_fcCint_1173_0_31, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&PamVMCDetector::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__PamVMC_fcCint_1173_0_32, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&PamVMCDetector::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__PamVMC_fcCintLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__PamVMC_fcCint_1173_0_36, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__PamVMC_fcCint_1173_0_37, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&PamVMCDetector::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__PamVMC_fcCint_1173_0_38, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&PamVMCDetector::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__PamVMC_fcCint_1173_0_39, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&PamVMCDetector::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__PamVMC_fcCint_1173_0_40, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&PamVMCDetector::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~PamVMCDetector", 1468, G__PamVMC_fcCint_1173_0_41, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncPamVMCCaloSD(void) {
   /* PamVMCCaloSD */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__PamVMC_fcCintLN_PamVMCCaloSD));
   G__memfunc_setup("PamVMCCaloSD",1050,G__PamVMC_fcCint_1174_0_1, 105, G__get_linked_tagnum(&G__PamVMC_fcCintLN_PamVMCCaloSD), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("FillHit",684,(G__InterfaceMethod) NULL,121, -1, -1, 0, 3, 1, 1, 0, 
"i 'fin' - 0 - f U 'TVirtualMC' - 0 - g "
"g - 'Bool_t' 0 - is_prim", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetPlaneID",925,G__PamVMC_fcCint_1174_0_3, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetViewID",840,G__PamVMC_fcCint_1174_0_4, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetStripID",959,G__PamVMC_fcCint_1174_0_5, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__PamVMC_fcCint_1174_0_6, 85, G__get_linked_tagnum(&G__PamVMC_fcCintLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&PamVMCCaloSD::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__PamVMC_fcCint_1174_0_7, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&PamVMCCaloSD::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__PamVMC_fcCint_1174_0_8, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&PamVMCCaloSD::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__PamVMC_fcCint_1174_0_9, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&PamVMCCaloSD::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__PamVMC_fcCintLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__PamVMC_fcCint_1174_0_13, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__PamVMC_fcCint_1174_0_14, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&PamVMCCaloSD::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__PamVMC_fcCint_1174_0_15, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&PamVMCCaloSD::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__PamVMC_fcCint_1174_0_16, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&PamVMCCaloSD::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__PamVMC_fcCint_1174_0_17, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&PamVMCCaloSD::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~PamVMCCaloSD", 1176, G__PamVMC_fcCint_1174_0_18, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncPamVMCDetCalo(void) {
   /* PamVMCDetCalo */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__PamVMC_fcCintLN_PamVMCDetCalo));
   G__memfunc_setup("PamVMCDetCalo",1184,G__PamVMC_fcCint_1175_0_1, 105, G__get_linked_tagnum(&G__PamVMC_fcCintLN_PamVMCDetCalo), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DefineGeometry",1431,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DefineCuts",1002,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("InitMC",548,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__PamVMC_fcCint_1175_0_5, 85, G__get_linked_tagnum(&G__PamVMC_fcCintLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&PamVMCDetCalo::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__PamVMC_fcCint_1175_0_6, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&PamVMCDetCalo::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__PamVMC_fcCint_1175_0_7, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&PamVMCDetCalo::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__PamVMC_fcCint_1175_0_8, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&PamVMCDetCalo::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__PamVMC_fcCintLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__PamVMC_fcCint_1175_0_12, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__PamVMC_fcCint_1175_0_13, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&PamVMCDetCalo::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__PamVMC_fcCint_1175_0_14, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&PamVMCDetCalo::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__PamVMC_fcCint_1175_0_15, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&PamVMCDetCalo::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__PamVMC_fcCint_1175_0_16, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&PamVMCDetCalo::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~PamVMCDetCalo", 1310, G__PamVMC_fcCint_1175_0_17, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncpTrkHitData(void) {
   /* pTrkHitData */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__PamVMC_fcCintLN_pTrkHitData));
   G__memfunc_setup("pTrkHitData",1088,G__PamVMC_fcCint_1184_0_1, 105, G__get_linked_tagnum(&G__PamVMC_fcCintLN_pTrkHitData), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Clean",483,G__PamVMC_fcCint_1184_0_2, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Clear",487,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Print",525,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "C - 'Option_t' 10 '\"\"' -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__PamVMC_fcCint_1184_0_5, 85, G__get_linked_tagnum(&G__PamVMC_fcCintLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&pTrkHitData::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__PamVMC_fcCint_1184_0_6, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&pTrkHitData::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__PamVMC_fcCint_1184_0_7, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&pTrkHitData::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__PamVMC_fcCint_1184_0_8, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&pTrkHitData::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__PamVMC_fcCintLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__PamVMC_fcCint_1184_0_12, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__PamVMC_fcCint_1184_0_13, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&pTrkHitData::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__PamVMC_fcCint_1184_0_14, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&pTrkHitData::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__PamVMC_fcCint_1184_0_15, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&pTrkHitData::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__PamVMC_fcCint_1184_0_16, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&pTrkHitData::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("pTrkHitData", 1088, G__PamVMC_fcCint_1184_0_17, (int) ('i'), G__get_linked_tagnum(&G__PamVMC_fcCintLN_pTrkHitData), -1, 0, 1, 1, 1, 0, "u 'pTrkHitData' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~pTrkHitData", 1214, G__PamVMC_fcCint_1184_0_18, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__PamVMC_fcCint_1184_0_19, (int) ('u'), G__get_linked_tagnum(&G__PamVMC_fcCintLN_pTrkHitData), -1, 1, 1, 1, 1, 0, "u 'pTrkHitData' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncPamVMCTrkHit(void) {
   /* PamVMCTrkHit */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__PamVMC_fcCintLN_PamVMCTrkHit));
   G__memfunc_setup("PamVMCTrkHit",1114,G__PamVMC_fcCint_1185_0_1, 105, G__get_linked_tagnum(&G__PamVMC_fcCintLN_PamVMCTrkHit), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CleanHit",776,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Clear",487,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GenTrkHit",880,G__PamVMC_fcCint_1185_0_4, 85, G__get_linked_tagnum(&G__PamVMC_fcCintLN_pTrkHitData), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,G__PamVMC_fcCint_1185_0_5, 121, -1, -1, 0, 1, 1, 1, 0, "u 'PamVMCTrkHit' - 11 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetNXMULT",788,G__PamVMC_fcCint_1185_0_6, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - xmult", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetNYMULT",789,G__PamVMC_fcCint_1185_0_7, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - ymult", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetXAVESPE",840,G__PamVMC_fcCint_1185_0_8, 121, -1, -1, 0, 1, 1, 1, 0, "f - 'Float_t' 0 - xave", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetYAVESPE",841,G__PamVMC_fcCint_1185_0_9, 121, -1, -1, 0, 1, 1, 1, 0, "f - 'Float_t' 0 - yave", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetZAVESPE",842,G__PamVMC_fcCint_1185_0_10, 121, -1, -1, 0, 1, 1, 1, 0, "f - 'Float_t' 0 - zave", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetTrkHit",886,G__PamVMC_fcCint_1185_0_11, 85, G__get_linked_tagnum(&G__PamVMC_fcCintLN_pTrkHitData), -1, 0, 0, 1, 1, 1, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetNXMULT",776,G__PamVMC_fcCint_1185_0_12, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetNYMULT",777,G__PamVMC_fcCint_1185_0_13, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetXAVESPE",828,G__PamVMC_fcCint_1185_0_14, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetYAVESPE",829,G__PamVMC_fcCint_1185_0_15, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetZAVESPE",830,G__PamVMC_fcCint_1185_0_16, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__PamVMC_fcCint_1185_0_17, 85, G__get_linked_tagnum(&G__PamVMC_fcCintLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&PamVMCTrkHit::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__PamVMC_fcCint_1185_0_18, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&PamVMCTrkHit::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__PamVMC_fcCint_1185_0_19, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&PamVMCTrkHit::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__PamVMC_fcCint_1185_0_20, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&PamVMCTrkHit::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__PamVMC_fcCintLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__PamVMC_fcCint_1185_0_24, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__PamVMC_fcCint_1185_0_25, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&PamVMCTrkHit::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__PamVMC_fcCint_1185_0_26, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&PamVMCTrkHit::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__PamVMC_fcCint_1185_0_27, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&PamVMCTrkHit::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__PamVMC_fcCint_1185_0_28, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&PamVMCTrkHit::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("PamVMCTrkHit", 1114, G__PamVMC_fcCint_1185_0_29, (int) ('i'), G__get_linked_tagnum(&G__PamVMC_fcCintLN_PamVMCTrkHit), -1, 0, 1, 1, 1, 0, "u 'PamVMCTrkHit' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~PamVMCTrkHit", 1240, G__PamVMC_fcCint_1185_0_30, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncPamVMCTrkSD(void) {
   /* PamVMCTrkSD */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__PamVMC_fcCintLN_PamVMCTrkSD));
   G__memfunc_setup("PamVMCTrkSD",972,G__PamVMC_fcCint_1188_0_1, 105, G__get_linked_tagnum(&G__PamVMC_fcCintLN_PamVMCTrkSD), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Init",404,G__PamVMC_fcCint_1188_0_2, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("PreEvent",809,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Register",837,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ClearHitColl",1174,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Compress",844,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SaveTrkHit",997,G__PamVMC_fcCint_1188_0_7, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - dname", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("CreateTrkHit",1194,G__PamVMC_fcCint_1188_0_8, 85, G__get_linked_tagnum(&G__PamVMC_fcCintLN_PamVMCTrkHit), -1, 0, 1, 1, 1, 0, "C - - 10 - dname", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("CreateTrkHit",1194,G__PamVMC_fcCint_1188_0_9, 85, G__get_linked_tagnum(&G__PamVMC_fcCintLN_PamVMCTrkHit), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("FillHit",684,(G__InterfaceMethod) NULL,121, -1, -1, 0, 3, 1, 1, 0, 
"i 'fin' - 0 - f U 'TVirtualMC' - 0 - g "
"g - 'Bool_t' 0 - is_prim", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetTrkHit",898,G__PamVMC_fcCint_1188_0_11, 121, -1, -1, 0, 1, 1, 1, 0, "U 'PamVMCTrkHit' - 0 - t", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("PreDigit",792,G__PamVMC_fcCint_1188_0_12, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Digitize",825,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetPlaneID",925,G__PamVMC_fcCint_1188_0_14, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetPadID",706,G__PamVMC_fcCint_1188_0_15, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__PamVMC_fcCint_1188_0_16, 85, G__get_linked_tagnum(&G__PamVMC_fcCintLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&PamVMCTrkSD::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__PamVMC_fcCint_1188_0_17, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&PamVMCTrkSD::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__PamVMC_fcCint_1188_0_18, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&PamVMCTrkSD::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__PamVMC_fcCint_1188_0_19, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&PamVMCTrkSD::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__PamVMC_fcCintLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__PamVMC_fcCint_1188_0_23, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__PamVMC_fcCint_1188_0_24, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&PamVMCTrkSD::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__PamVMC_fcCint_1188_0_25, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&PamVMCTrkSD::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__PamVMC_fcCint_1188_0_26, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&PamVMCTrkSD::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__PamVMC_fcCint_1188_0_27, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&PamVMCTrkSD::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~PamVMCTrkSD", 1098, G__PamVMC_fcCint_1188_0_28, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncPamVMCDetTrk(void) {
   /* PamVMCDetTrk */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__PamVMC_fcCintLN_PamVMCDetTrk));
   G__memfunc_setup("ReadPaddlesPos",1387,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("PamVMCDetTrk",1106,G__PamVMC_fcCint_1189_0_2, 105, G__get_linked_tagnum(&G__PamVMC_fcCintLN_PamVMCDetTrk), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DefineGeometry",1431,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DefineCuts",1002,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("InitMC",548,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__PamVMC_fcCint_1189_0_6, 85, G__get_linked_tagnum(&G__PamVMC_fcCintLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&PamVMCDetTrk::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__PamVMC_fcCint_1189_0_7, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&PamVMCDetTrk::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__PamVMC_fcCint_1189_0_8, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&PamVMCDetTrk::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__PamVMC_fcCint_1189_0_9, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&PamVMCDetTrk::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__PamVMC_fcCintLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__PamVMC_fcCint_1189_0_13, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__PamVMC_fcCint_1189_0_14, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&PamVMCDetTrk::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__PamVMC_fcCint_1189_0_15, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&PamVMCDetTrk::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__PamVMC_fcCint_1189_0_16, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&PamVMCDetTrk::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__PamVMC_fcCint_1189_0_17, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&PamVMCDetTrk::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~PamVMCDetTrk", 1232, G__PamVMC_fcCint_1189_0_18, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncPamVMCTofSD(void) {
   /* PamVMCTofSD */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__PamVMC_fcCintLN_PamVMCTofSD));
   G__memfunc_setup("PamVMCTofSD",964,G__PamVMC_fcCint_1190_0_1, 105, G__get_linked_tagnum(&G__PamVMC_fcCintLN_PamVMCTofSD), -1, 0, 1, 1, 1, 0, "C - - 10 - dname", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__PamVMC_fcCint_1190_0_2, 85, G__get_linked_tagnum(&G__PamVMC_fcCintLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&PamVMCTofSD::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__PamVMC_fcCint_1190_0_3, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&PamVMCTofSD::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__PamVMC_fcCint_1190_0_4, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&PamVMCTofSD::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__PamVMC_fcCint_1190_0_5, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&PamVMCTofSD::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__PamVMC_fcCintLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__PamVMC_fcCint_1190_0_9, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__PamVMC_fcCint_1190_0_10, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&PamVMCTofSD::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__PamVMC_fcCint_1190_0_11, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&PamVMCTofSD::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__PamVMC_fcCint_1190_0_12, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&PamVMCTofSD::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__PamVMC_fcCint_1190_0_13, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&PamVMCTofSD::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~PamVMCTofSD", 1090, G__PamVMC_fcCint_1190_0_14, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncPamVMCDetTofS1(void) {
   /* PamVMCDetTofS1 */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__PamVMC_fcCintLN_PamVMCDetTofS1));
   G__memfunc_setup("PamVMCDetTofS1",1230,G__PamVMC_fcCint_1191_0_1, 105, G__get_linked_tagnum(&G__PamVMC_fcCintLN_PamVMCDetTofS1), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DefineGeometry",1431,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DefineCuts",1002,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("InitMC",548,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__PamVMC_fcCint_1191_0_5, 85, G__get_linked_tagnum(&G__PamVMC_fcCintLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&PamVMCDetTofS1::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__PamVMC_fcCint_1191_0_6, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&PamVMCDetTofS1::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__PamVMC_fcCint_1191_0_7, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&PamVMCDetTofS1::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__PamVMC_fcCint_1191_0_8, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&PamVMCDetTofS1::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__PamVMC_fcCintLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__PamVMC_fcCint_1191_0_12, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__PamVMC_fcCint_1191_0_13, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&PamVMCDetTofS1::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__PamVMC_fcCint_1191_0_14, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&PamVMCDetTofS1::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__PamVMC_fcCint_1191_0_15, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&PamVMCDetTofS1::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__PamVMC_fcCint_1191_0_16, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&PamVMCDetTofS1::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~PamVMCDetTofS1", 1356, G__PamVMC_fcCint_1191_0_17, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncPamVMCDetTofS2(void) {
   /* PamVMCDetTofS2 */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__PamVMC_fcCintLN_PamVMCDetTofS2));
   G__memfunc_setup("PamVMCDetTofS2",1231,G__PamVMC_fcCint_1192_0_1, 105, G__get_linked_tagnum(&G__PamVMC_fcCintLN_PamVMCDetTofS2), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DefineGeometry",1431,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DefineCuts",1002,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("InitMC",548,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__PamVMC_fcCint_1192_0_5, 85, G__get_linked_tagnum(&G__PamVMC_fcCintLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&PamVMCDetTofS2::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__PamVMC_fcCint_1192_0_6, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&PamVMCDetTofS2::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__PamVMC_fcCint_1192_0_7, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&PamVMCDetTofS2::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__PamVMC_fcCint_1192_0_8, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&PamVMCDetTofS2::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__PamVMC_fcCintLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__PamVMC_fcCint_1192_0_12, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__PamVMC_fcCint_1192_0_13, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&PamVMCDetTofS2::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__PamVMC_fcCint_1192_0_14, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&PamVMCDetTofS2::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__PamVMC_fcCint_1192_0_15, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&PamVMCDetTofS2::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__PamVMC_fcCint_1192_0_16, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&PamVMCDetTofS2::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~PamVMCDetTofS2", 1357, G__PamVMC_fcCint_1192_0_17, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncPamVMCDetTofS3(void) {
   /* PamVMCDetTofS3 */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__PamVMC_fcCintLN_PamVMCDetTofS3));
   G__memfunc_setup("PamVMCDetTofS3",1232,G__PamVMC_fcCint_1193_0_1, 105, G__get_linked_tagnum(&G__PamVMC_fcCintLN_PamVMCDetTofS3), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DefineGeometry",1431,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DefineCuts",1002,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("InitMC",548,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__PamVMC_fcCint_1193_0_5, 85, G__get_linked_tagnum(&G__PamVMC_fcCintLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&PamVMCDetTofS3::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__PamVMC_fcCint_1193_0_6, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&PamVMCDetTofS3::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__PamVMC_fcCint_1193_0_7, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&PamVMCDetTofS3::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__PamVMC_fcCint_1193_0_8, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&PamVMCDetTofS3::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__PamVMC_fcCintLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__PamVMC_fcCint_1193_0_12, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__PamVMC_fcCint_1193_0_13, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&PamVMCDetTofS3::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__PamVMC_fcCint_1193_0_14, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&PamVMCDetTofS3::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__PamVMC_fcCint_1193_0_15, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&PamVMCDetTofS3::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__PamVMC_fcCint_1193_0_16, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&PamVMCDetTofS3::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~PamVMCDetTofS3", 1358, G__PamVMC_fcCint_1193_0_17, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncPamVMCDetTof(void) {
   /* PamVMCDetTof */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__PamVMC_fcCintLN_PamVMCDetTof));
   G__memfunc_setup("PamVMCDetTof",1098,G__PamVMC_fcCint_1194_0_1, 105, G__get_linked_tagnum(&G__PamVMC_fcCintLN_PamVMCDetTof), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DefineGeometry",1431,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DefineCuts",1002,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__PamVMC_fcCint_1194_0_4, 85, G__get_linked_tagnum(&G__PamVMC_fcCintLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&PamVMCDetTof::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__PamVMC_fcCint_1194_0_5, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&PamVMCDetTof::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__PamVMC_fcCint_1194_0_6, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&PamVMCDetTof::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__PamVMC_fcCint_1194_0_7, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&PamVMCDetTof::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__PamVMC_fcCintLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__PamVMC_fcCint_1194_0_11, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__PamVMC_fcCint_1194_0_12, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&PamVMCDetTof::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__PamVMC_fcCint_1194_0_13, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&PamVMCDetTof::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__PamVMC_fcCint_1194_0_14, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&PamVMCDetTof::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__PamVMC_fcCint_1194_0_15, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&PamVMCDetTof::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~PamVMCDetTof", 1224, G__PamVMC_fcCint_1194_0_16, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncPamVMCCardSD(void) {
   /* PamVMCCardSD */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__PamVMC_fcCintLN_PamVMCCardSD));
   G__memfunc_setup("PamVMCCardSD",1045,G__PamVMC_fcCint_1195_0_1, 105, G__get_linked_tagnum(&G__PamVMC_fcCintLN_PamVMCCardSD), -1, 0, 1, 1, 1, 0, "C - - 10 - dname", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__PamVMC_fcCint_1195_0_2, 85, G__get_linked_tagnum(&G__PamVMC_fcCintLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&PamVMCCardSD::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__PamVMC_fcCint_1195_0_3, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&PamVMCCardSD::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__PamVMC_fcCint_1195_0_4, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&PamVMCCardSD::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__PamVMC_fcCint_1195_0_5, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&PamVMCCardSD::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__PamVMC_fcCintLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__PamVMC_fcCint_1195_0_9, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__PamVMC_fcCint_1195_0_10, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&PamVMCCardSD::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__PamVMC_fcCint_1195_0_11, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&PamVMCCardSD::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__PamVMC_fcCint_1195_0_12, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&PamVMCCardSD::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__PamVMC_fcCint_1195_0_13, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&PamVMCCardSD::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~PamVMCCardSD", 1171, G__PamVMC_fcCint_1195_0_14, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncPamVMCDetCard(void) {
   /* PamVMCDetCard */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__PamVMC_fcCintLN_PamVMCDetCard));
   G__memfunc_setup("PamVMCDetCard",1179,G__PamVMC_fcCint_1196_0_1, 105, G__get_linked_tagnum(&G__PamVMC_fcCintLN_PamVMCDetCard), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DefineGeometry",1431,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DefineCuts",1002,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("InitMC",548,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__PamVMC_fcCint_1196_0_5, 85, G__get_linked_tagnum(&G__PamVMC_fcCintLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&PamVMCDetCard::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__PamVMC_fcCint_1196_0_6, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&PamVMCDetCard::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__PamVMC_fcCint_1196_0_7, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&PamVMCDetCard::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__PamVMC_fcCint_1196_0_8, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&PamVMCDetCard::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__PamVMC_fcCintLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__PamVMC_fcCint_1196_0_12, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__PamVMC_fcCint_1196_0_13, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&PamVMCDetCard::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__PamVMC_fcCint_1196_0_14, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&PamVMCDetCard::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__PamVMC_fcCint_1196_0_15, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&PamVMCDetCard::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__PamVMC_fcCint_1196_0_16, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&PamVMCDetCard::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~PamVMCDetCard", 1305, G__PamVMC_fcCint_1196_0_17, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncPamVMCCasSD(void) {
   /* PamVMCCasSD */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__PamVMC_fcCintLN_PamVMCCasSD));
   G__memfunc_setup("PamVMCCasSD",946,G__PamVMC_fcCint_1197_0_1, 105, G__get_linked_tagnum(&G__PamVMC_fcCintLN_PamVMCCasSD), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__PamVMC_fcCint_1197_0_2, 85, G__get_linked_tagnum(&G__PamVMC_fcCintLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&PamVMCCasSD::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__PamVMC_fcCint_1197_0_3, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&PamVMCCasSD::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__PamVMC_fcCint_1197_0_4, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&PamVMCCasSD::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__PamVMC_fcCint_1197_0_5, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&PamVMCCasSD::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__PamVMC_fcCintLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__PamVMC_fcCint_1197_0_9, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__PamVMC_fcCint_1197_0_10, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&PamVMCCasSD::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__PamVMC_fcCint_1197_0_11, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&PamVMCCasSD::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__PamVMC_fcCint_1197_0_12, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&PamVMCCasSD::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__PamVMC_fcCint_1197_0_13, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&PamVMCCasSD::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~PamVMCCasSD", 1072, G__PamVMC_fcCint_1197_0_14, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncPamVMCDetCas(void) {
   /* PamVMCDetCas */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__PamVMC_fcCintLN_PamVMCDetCas));
   G__memfunc_setup("PamVMCDetCas",1080,G__PamVMC_fcCint_1198_0_1, 105, G__get_linked_tagnum(&G__PamVMC_fcCintLN_PamVMCDetCas), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DefineGeometry",1431,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DefineCuts",1002,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("InitMC",548,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__PamVMC_fcCint_1198_0_5, 85, G__get_linked_tagnum(&G__PamVMC_fcCintLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&PamVMCDetCas::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__PamVMC_fcCint_1198_0_6, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&PamVMCDetCas::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__PamVMC_fcCint_1198_0_7, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&PamVMCDetCas::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__PamVMC_fcCint_1198_0_8, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&PamVMCDetCas::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__PamVMC_fcCintLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__PamVMC_fcCint_1198_0_12, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__PamVMC_fcCint_1198_0_13, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&PamVMCDetCas::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__PamVMC_fcCint_1198_0_14, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&PamVMCDetCas::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__PamVMC_fcCint_1198_0_15, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&PamVMCDetCas::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__PamVMC_fcCint_1198_0_16, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&PamVMCDetCas::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~PamVMCDetCas", 1206, G__PamVMC_fcCint_1198_0_17, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncPamVMCCatSD(void) {
   /* PamVMCCatSD */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__PamVMC_fcCintLN_PamVMCCatSD));
   G__memfunc_setup("PamVMCCatSD",947,G__PamVMC_fcCint_1199_0_1, 105, G__get_linked_tagnum(&G__PamVMC_fcCintLN_PamVMCCatSD), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__PamVMC_fcCint_1199_0_2, 85, G__get_linked_tagnum(&G__PamVMC_fcCintLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&PamVMCCatSD::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__PamVMC_fcCint_1199_0_3, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&PamVMCCatSD::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__PamVMC_fcCint_1199_0_4, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&PamVMCCatSD::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__PamVMC_fcCint_1199_0_5, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&PamVMCCatSD::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__PamVMC_fcCintLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__PamVMC_fcCint_1199_0_9, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__PamVMC_fcCint_1199_0_10, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&PamVMCCatSD::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__PamVMC_fcCint_1199_0_11, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&PamVMCCatSD::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__PamVMC_fcCint_1199_0_12, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&PamVMCCatSD::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__PamVMC_fcCint_1199_0_13, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&PamVMCCatSD::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~PamVMCCatSD", 1073, G__PamVMC_fcCint_1199_0_14, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncPamVMCDetCat(void) {
   /* PamVMCDetCat */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__PamVMC_fcCintLN_PamVMCDetCat));
   G__memfunc_setup("PamVMCDetCat",1081,G__PamVMC_fcCint_1200_0_1, 105, G__get_linked_tagnum(&G__PamVMC_fcCintLN_PamVMCDetCat), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DefineGeometry",1431,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DefineCuts",1002,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("InitMC",548,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__PamVMC_fcCint_1200_0_5, 85, G__get_linked_tagnum(&G__PamVMC_fcCintLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&PamVMCDetCat::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__PamVMC_fcCint_1200_0_6, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&PamVMCDetCat::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__PamVMC_fcCint_1200_0_7, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&PamVMCDetCat::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__PamVMC_fcCint_1200_0_8, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&PamVMCDetCat::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__PamVMC_fcCintLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__PamVMC_fcCint_1200_0_12, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__PamVMC_fcCint_1200_0_13, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&PamVMCDetCat::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__PamVMC_fcCint_1200_0_14, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&PamVMCDetCat::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__PamVMC_fcCint_1200_0_15, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&PamVMCDetCat::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__PamVMC_fcCint_1200_0_16, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&PamVMCDetCat::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~PamVMCDetCat", 1207, G__PamVMC_fcCint_1200_0_17, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncPamVMCDetAc(void) {
   /* PamVMCDetAc */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__PamVMC_fcCintLN_PamVMCDetAc));
   G__memfunc_setup("PamVMCDetAc",965,G__PamVMC_fcCint_1201_0_1, 105, G__get_linked_tagnum(&G__PamVMC_fcCintLN_PamVMCDetAc), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DefineGeometry",1431,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DefineCuts",1002,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__PamVMC_fcCint_1201_0_4, 85, G__get_linked_tagnum(&G__PamVMC_fcCintLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&PamVMCDetAc::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__PamVMC_fcCint_1201_0_5, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&PamVMCDetAc::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__PamVMC_fcCint_1201_0_6, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&PamVMCDetAc::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__PamVMC_fcCint_1201_0_7, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&PamVMCDetAc::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__PamVMC_fcCintLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__PamVMC_fcCint_1201_0_11, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__PamVMC_fcCint_1201_0_12, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&PamVMCDetAc::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__PamVMC_fcCint_1201_0_13, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&PamVMCDetAc::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__PamVMC_fcCint_1201_0_14, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&PamVMCDetAc::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__PamVMC_fcCint_1201_0_15, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&PamVMCDetAc::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~PamVMCDetAc", 1091, G__PamVMC_fcCint_1201_0_16, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncPamVMCS4SD(void) {
   /* PamVMCS4SD */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__PamVMC_fcCintLN_PamVMCS4SD));
   G__memfunc_setup("PamVMCS4SD",802,G__PamVMC_fcCint_1202_0_1, 105, G__get_linked_tagnum(&G__PamVMC_fcCintLN_PamVMCS4SD), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__PamVMC_fcCint_1202_0_2, 85, G__get_linked_tagnum(&G__PamVMC_fcCintLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&PamVMCS4SD::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__PamVMC_fcCint_1202_0_3, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&PamVMCS4SD::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__PamVMC_fcCint_1202_0_4, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&PamVMCS4SD::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__PamVMC_fcCint_1202_0_5, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&PamVMCS4SD::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__PamVMC_fcCintLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__PamVMC_fcCint_1202_0_9, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__PamVMC_fcCint_1202_0_10, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&PamVMCS4SD::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__PamVMC_fcCint_1202_0_11, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&PamVMCS4SD::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__PamVMC_fcCint_1202_0_12, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&PamVMCS4SD::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__PamVMC_fcCint_1202_0_13, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&PamVMCS4SD::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~PamVMCS4SD", 928, G__PamVMC_fcCint_1202_0_14, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncPamVMCDetS4(void) {
   /* PamVMCDetS4 */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__PamVMC_fcCintLN_PamVMCDetS4));
   G__memfunc_setup("PamVMCDetS4",936,G__PamVMC_fcCint_1203_0_1, 105, G__get_linked_tagnum(&G__PamVMC_fcCintLN_PamVMCDetS4), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DefineGeometry",1431,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DefineCuts",1002,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("InitMC",548,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__PamVMC_fcCint_1203_0_5, 85, G__get_linked_tagnum(&G__PamVMC_fcCintLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&PamVMCDetS4::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__PamVMC_fcCint_1203_0_6, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&PamVMCDetS4::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__PamVMC_fcCint_1203_0_7, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&PamVMCDetS4::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__PamVMC_fcCint_1203_0_8, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&PamVMCDetS4::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__PamVMC_fcCintLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__PamVMC_fcCint_1203_0_12, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__PamVMC_fcCint_1203_0_13, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&PamVMCDetS4::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__PamVMC_fcCint_1203_0_14, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&PamVMCDetS4::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__PamVMC_fcCint_1203_0_15, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&PamVMCDetS4::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__PamVMC_fcCint_1203_0_16, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&PamVMCDetS4::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~PamVMCDetS4", 1062, G__PamVMC_fcCint_1203_0_17, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncPamVMCNDSD(void) {
   /* PamVMCNDSD */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__PamVMC_fcCintLN_PamVMCNDSD));
   G__memfunc_setup("PamVMCNDSD",813,G__PamVMC_fcCint_1204_0_1, 105, G__get_linked_tagnum(&G__PamVMC_fcCintLN_PamVMCNDSD), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__PamVMC_fcCint_1204_0_2, 85, G__get_linked_tagnum(&G__PamVMC_fcCintLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&PamVMCNDSD::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__PamVMC_fcCint_1204_0_3, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&PamVMCNDSD::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__PamVMC_fcCint_1204_0_4, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&PamVMCNDSD::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__PamVMC_fcCint_1204_0_5, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&PamVMCNDSD::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__PamVMC_fcCintLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__PamVMC_fcCint_1204_0_9, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__PamVMC_fcCint_1204_0_10, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&PamVMCNDSD::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__PamVMC_fcCint_1204_0_11, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&PamVMCNDSD::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__PamVMC_fcCint_1204_0_12, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&PamVMCNDSD::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__PamVMC_fcCint_1204_0_13, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&PamVMCNDSD::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~PamVMCNDSD", 939, G__PamVMC_fcCint_1204_0_14, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncPamVMCDetND(void) {
   /* PamVMCDetND */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__PamVMC_fcCintLN_PamVMCDetND));
   G__memfunc_setup("PamVMCDetND",947,G__PamVMC_fcCint_1205_0_1, 105, G__get_linked_tagnum(&G__PamVMC_fcCintLN_PamVMCDetND), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DefineGeometry",1431,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DefineCuts",1002,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("InitMC",548,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__PamVMC_fcCint_1205_0_5, 85, G__get_linked_tagnum(&G__PamVMC_fcCintLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&PamVMCDetND::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__PamVMC_fcCint_1205_0_6, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&PamVMCDetND::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__PamVMC_fcCint_1205_0_7, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&PamVMCDetND::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__PamVMC_fcCint_1205_0_8, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&PamVMCDetND::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__PamVMC_fcCintLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__PamVMC_fcCint_1205_0_12, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__PamVMC_fcCint_1205_0_13, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&PamVMCDetND::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__PamVMC_fcCint_1205_0_14, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&PamVMCDetND::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__PamVMC_fcCint_1205_0_15, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&PamVMCDetND::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__PamVMC_fcCint_1205_0_16, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&PamVMCDetND::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~PamVMCDetND", 1073, G__PamVMC_fcCint_1205_0_17, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncPamVMCDetPamela(void) {
   /* PamVMCDetPamela */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__PamVMC_fcCintLN_PamVMCDetPamela));
   G__memfunc_setup("PamVMCDetPamela",1393,G__PamVMC_fcCint_1206_0_1, 105, G__get_linked_tagnum(&G__PamVMC_fcCintLN_PamVMCDetPamela), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DefineMother",1210,G__PamVMC_fcCint_1206_0_2, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DefineShell",1091,G__PamVMC_fcCint_1206_0_3, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DefineCuts",1002,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DefineGeometry",1431,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetMotherVol",1216,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__PamVMC_fcCintLN_TGeoVolume), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__PamVMC_fcCint_1206_0_7, 85, G__get_linked_tagnum(&G__PamVMC_fcCintLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&PamVMCDetPamela::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__PamVMC_fcCint_1206_0_8, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&PamVMCDetPamela::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__PamVMC_fcCint_1206_0_9, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&PamVMCDetPamela::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__PamVMC_fcCint_1206_0_10, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&PamVMCDetPamela::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__PamVMC_fcCintLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__PamVMC_fcCint_1206_0_14, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__PamVMC_fcCint_1206_0_15, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&PamVMCDetPamela::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__PamVMC_fcCint_1206_0_16, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&PamVMCDetPamela::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__PamVMC_fcCint_1206_0_17, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&PamVMCDetPamela::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__PamVMC_fcCint_1206_0_18, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&PamVMCDetPamela::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~PamVMCDetPamela", 1519, G__PamVMC_fcCint_1206_0_19, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncPamVMCApplication(void) {
   /* PamVMCApplication */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__PamVMC_fcCintLN_PamVMCApplication));
   G__memfunc_setup("PamVMCApplication",1656,G__PamVMC_fcCint_1208_0_1, 105, G__get_linked_tagnum(&G__PamVMC_fcCintLN_PamVMCApplication), -1, 0, 4, 1, 1, 0, 
"C - - 10 - name C - - 10 - title "
"C - - 10 '\"pamtest\"' filename i - 'Int_t' 0 '0' seed", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Instance",821,G__PamVMC_fcCint_1208_0_2, 85, G__get_linked_tagnum(&G__PamVMC_fcCintLN_PamVMCApplication), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (PamVMCApplication* (*)())(&PamVMCApplication::Instance) ), 0);
   G__memfunc_setup("SetRandom",909,G__PamVMC_fcCint_1208_0_3, 121, -1, -1, 0, 2, 1, 1, 0, 
"C - - 10 - dname U 'TRandom3' - 0 - random", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetTrigger",1012,G__PamVMC_fcCint_1208_0_4, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("InitMC",548,G__PamVMC_fcCint_1208_0_5, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - setup", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("RunMC",453,G__PamVMC_fcCint_1208_0_6, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - nofEvents", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddIons",674,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("FillEv",578,G__PamVMC_fcCint_1208_0_8, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ConstructGeometry",1809,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("InitGeometry",1248,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GeneratePrimaries",1751,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("BeginEvent",999,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("BeginPrimary",1225,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("PreTrack",796,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Stepping",842,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("PostTrack",923,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("FinishPrimary",1349,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("FinishEvent",1123,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("FinishRun",918,G__PamVMC_fcCint_1208_0_19, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetVerboseLevel",1530,G__PamVMC_fcCint_1208_0_20, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - verboseLevel", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetPrimaryGenerator",1963,G__PamVMC_fcCint_1208_0_21, 85, G__get_linked_tagnum(&G__PamVMC_fcCintLN_PamVMCPrimaryGenerator), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__PamVMC_fcCint_1208_0_22, 85, G__get_linked_tagnum(&G__PamVMC_fcCintLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&PamVMCApplication::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__PamVMC_fcCint_1208_0_23, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&PamVMCApplication::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__PamVMC_fcCint_1208_0_24, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&PamVMCApplication::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__PamVMC_fcCint_1208_0_25, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&PamVMCApplication::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__PamVMC_fcCintLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__PamVMC_fcCint_1208_0_29, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__PamVMC_fcCint_1208_0_30, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&PamVMCApplication::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__PamVMC_fcCint_1208_0_31, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&PamVMCApplication::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__PamVMC_fcCint_1208_0_32, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&PamVMCApplication::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__PamVMC_fcCint_1208_0_33, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&PamVMCApplication::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("PamVMCApplication", 1656, G__PamVMC_fcCint_1208_0_34, (int) ('i'), G__get_linked_tagnum(&G__PamVMC_fcCintLN_PamVMCApplication), -1, 0, 1, 1, 1, 0, "u 'PamVMCApplication' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~PamVMCApplication", 1782, G__PamVMC_fcCint_1208_0_35, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__PamVMC_fcCint_1208_0_36, (int) ('u'), G__get_linked_tagnum(&G__PamVMC_fcCintLN_PamVMCApplication), -1, 1, 1, 1, 1, 0, "u 'PamVMCApplication' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}


/*********************************************************
* Member function information setup
*********************************************************/
extern "C" void G__cpp_setup_memfuncPamVMC_fcCint() {
}

/*********************************************************
* Global variable information setup for each class
*********************************************************/
static void G__cpp_setup_global0() {

   /* Setting up global variables */
   G__resetplocal();

}

static void G__cpp_setup_global1() {
}

static void G__cpp_setup_global2() {
}

static void G__cpp_setup_global3() {
}

static void G__cpp_setup_global4() {
}

static void G__cpp_setup_global5() {
}

static void G__cpp_setup_global6() {
}

static void G__cpp_setup_global7() {
}

static void G__cpp_setup_global8() {
}

static void G__cpp_setup_global9() {
}

static void G__cpp_setup_global10() {
}

static void G__cpp_setup_global11() {

   G__resetglobalenv();
}
extern "C" void G__cpp_setup_globalPamVMC_fcCint() {
  G__cpp_setup_global0();
  G__cpp_setup_global1();
  G__cpp_setup_global2();
  G__cpp_setup_global3();
  G__cpp_setup_global4();
  G__cpp_setup_global5();
  G__cpp_setup_global6();
  G__cpp_setup_global7();
  G__cpp_setup_global8();
  G__cpp_setup_global9();
  G__cpp_setup_global10();
  G__cpp_setup_global11();
}

/*********************************************************
* Global function information setup for each class
*********************************************************/
static void G__cpp_setup_func0() {
   G__lastifuncposition();

}

static void G__cpp_setup_func1() {
}

static void G__cpp_setup_func2() {
}

static void G__cpp_setup_func3() {
}

static void G__cpp_setup_func4() {
}

static void G__cpp_setup_func5() {
}

static void G__cpp_setup_func6() {
}

static void G__cpp_setup_func7() {
}

static void G__cpp_setup_func8() {
}

static void G__cpp_setup_func9() {
}

static void G__cpp_setup_func10() {
}

static void G__cpp_setup_func11() {
}

static void G__cpp_setup_func12() {
}

static void G__cpp_setup_func13() {
}

static void G__cpp_setup_func14() {
}

static void G__cpp_setup_func15() {
}

static void G__cpp_setup_func16() {
}

static void G__cpp_setup_func17() {
}

static void G__cpp_setup_func18() {
}

static void G__cpp_setup_func19() {
}

static void G__cpp_setup_func20() {
}

static void G__cpp_setup_func21() {
}

static void G__cpp_setup_func22() {
}

static void G__cpp_setup_func23() {
}

static void G__cpp_setup_func24() {
}

static void G__cpp_setup_func25() {
}

static void G__cpp_setup_func26() {
}

static void G__cpp_setup_func27() {
}

static void G__cpp_setup_func28() {
}

static void G__cpp_setup_func29() {
}

static void G__cpp_setup_func30() {
}

static void G__cpp_setup_func31() {
}

static void G__cpp_setup_func32() {
}

static void G__cpp_setup_func33() {
}

static void G__cpp_setup_func34() {
}

static void G__cpp_setup_func35() {
}

static void G__cpp_setup_func36() {

   G__resetifuncposition();
}

extern "C" void G__cpp_setup_funcPamVMC_fcCint() {
  G__cpp_setup_func0();
  G__cpp_setup_func1();
  G__cpp_setup_func2();
  G__cpp_setup_func3();
  G__cpp_setup_func4();
  G__cpp_setup_func5();
  G__cpp_setup_func6();
  G__cpp_setup_func7();
  G__cpp_setup_func8();
  G__cpp_setup_func9();
  G__cpp_setup_func10();
  G__cpp_setup_func11();
  G__cpp_setup_func12();
  G__cpp_setup_func13();
  G__cpp_setup_func14();
  G__cpp_setup_func15();
  G__cpp_setup_func16();
  G__cpp_setup_func17();
  G__cpp_setup_func18();
  G__cpp_setup_func19();
  G__cpp_setup_func20();
  G__cpp_setup_func21();
  G__cpp_setup_func22();
  G__cpp_setup_func23();
  G__cpp_setup_func24();
  G__cpp_setup_func25();
  G__cpp_setup_func26();
  G__cpp_setup_func27();
  G__cpp_setup_func28();
  G__cpp_setup_func29();
  G__cpp_setup_func30();
  G__cpp_setup_func31();
  G__cpp_setup_func32();
  G__cpp_setup_func33();
  G__cpp_setup_func34();
  G__cpp_setup_func35();
  G__cpp_setup_func36();
}

/*********************************************************
* Class,struct,union,enum tag information setup
*********************************************************/
/* Setup class/struct taginfo */
G__linked_taginfo G__PamVMC_fcCintLN_TClass = { "TClass" , 99 , -1 };
G__linked_taginfo G__PamVMC_fcCintLN_TBuffer = { "TBuffer" , 99 , -1 };
G__linked_taginfo G__PamVMC_fcCintLN_TDirectory = { "TDirectory" , 99 , -1 };
G__linked_taginfo G__PamVMC_fcCintLN_TMemberInspector = { "TMemberInspector" , 99 , -1 };
G__linked_taginfo G__PamVMC_fcCintLN_TObject = { "TObject" , 99 , -1 };
G__linked_taginfo G__PamVMC_fcCintLN_TNamed = { "TNamed" , 99 , -1 };
G__linked_taginfo G__PamVMC_fcCintLN_TString = { "TString" , 99 , -1 };
G__linked_taginfo G__PamVMC_fcCintLN_vectorlEunsignedsPcharcOallocatorlEunsignedsPchargRsPgR = { "vector<unsigned char,allocator<unsigned char> >" , 99 , -1 };
G__linked_taginfo G__PamVMC_fcCintLN_vectorlEunsignedsPshortcOallocatorlEunsignedsPshortgRsPgR = { "vector<unsigned short,allocator<unsigned short> >" , 99 , -1 };
G__linked_taginfo G__PamVMC_fcCintLN_vectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgR = { "vector<unsigned int,allocator<unsigned int> >" , 99 , -1 };
G__linked_taginfo G__PamVMC_fcCintLN_vectorlEdoublecOallocatorlEdoublegRsPgR = { "vector<double,allocator<double> >" , 99 , -1 };
G__linked_taginfo G__PamVMC_fcCintLN_basic_ifstreamlEcharcOchar_traitslEchargRsPgR = { "basic_ifstream<char,char_traits<char> >" , 99 , -1 };
G__linked_taginfo G__PamVMC_fcCintLN_basic_stringstreamlEcharcOchar_traitslEchargRcOallocatorlEchargRsPgR = { "basic_stringstream<char,char_traits<char>,allocator<char> >" , 99 , -1 };
G__linked_taginfo G__PamVMC_fcCintLN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR = { "vector<ROOT::TSchemaHelper,allocator<ROOT::TSchemaHelper> >" , 99 , -1 };
G__linked_taginfo G__PamVMC_fcCintLN_reverse_iteratorlEvectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgRcLcLiteratorgR = { "reverse_iterator<vector<ROOT::TSchemaHelper,allocator<ROOT::TSchemaHelper> >::iterator>" , 99 , -1 };
G__linked_taginfo G__PamVMC_fcCintLN_TObjArray = { "TObjArray" , 99 , -1 };
G__linked_taginfo G__PamVMC_fcCintLN_TClonesArray = { "TClonesArray" , 99 , -1 };
G__linked_taginfo G__PamVMC_fcCintLN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR = { "vector<TVirtualArray*,allocator<TVirtualArray*> >" , 99 , -1 };
G__linked_taginfo G__PamVMC_fcCintLN_reverse_iteratorlEvectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<TVirtualArray*,allocator<TVirtualArray*> >::iterator>" , 99 , -1 };
G__linked_taginfo G__PamVMC_fcCintLN_iteratorlEbidirectional_iterator_tagcOTObjectmUcOlongcOconstsPTObjectmUmUcOconstsPTObjectmUaNgR = { "iterator<bidirectional_iterator_tag,TObject*,long,const TObject**,const TObject*&>" , 115 , -1 };
G__linked_taginfo G__PamVMC_fcCintLN_TTree = { "TTree" , 99 , -1 };
G__linked_taginfo G__PamVMC_fcCintLN_TFile = { "TFile" , 99 , -1 };
G__linked_taginfo G__PamVMC_fcCintLN_TAttLine = { "TAttLine" , 99 , -1 };
G__linked_taginfo G__PamVMC_fcCintLN_maplElongcOintcOlesslElonggRcOallocatorlEpairlEconstsPlongcOintgRsPgRsPgR = { "map<long,int,less<long>,allocator<pair<const long,int> > >" , 99 , -1 };
G__linked_taginfo G__PamVMC_fcCintLN_maplEstringcOTObjArraymUcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOTObjArraymUgRsPgRsPgR = { "map<string,TObjArray*,less<string>,allocator<pair<const string,TObjArray*> > >" , 99 , -1 };
G__linked_taginfo G__PamVMC_fcCintLN_TMap = { "TMap" , 99 , -1 };
G__linked_taginfo G__PamVMC_fcCintLN_TParticle = { "TParticle" , 99 , -1 };
G__linked_taginfo G__PamVMC_fcCintLN_FileMode = { "FileMode" , 101 , -1 };
G__linked_taginfo G__PamVMC_fcCintLN_PamRootManager = { "PamRootManager" , 99 , -1 };
G__linked_taginfo G__PamVMC_fcCintLN_TRandom = { "TRandom" , 99 , -1 };
G__linked_taginfo G__PamVMC_fcCintLN_TVector2 = { "TVector2" , 99 , -1 };
G__linked_taginfo G__PamVMC_fcCintLN_TMatrixTBaselEfloatgR = { "TMatrixTBase<float>" , 99 , -1 };
G__linked_taginfo G__PamVMC_fcCintLN_TMatrixTBaselEdoublegR = { "TMatrixTBase<double>" , 99 , -1 };
G__linked_taginfo G__PamVMC_fcCintLN_TVectorTlEfloatgR = { "TVectorT<float>" , 99 , -1 };
G__linked_taginfo G__PamVMC_fcCintLN_TVectorTlEdoublegR = { "TVectorT<double>" , 99 , -1 };
G__linked_taginfo G__PamVMC_fcCintLN_TElementActionTlEfloatgR = { "TElementActionT<float>" , 99 , -1 };
G__linked_taginfo G__PamVMC_fcCintLN_TElementPosActionTlEfloatgR = { "TElementPosActionT<float>" , 99 , -1 };
G__linked_taginfo G__PamVMC_fcCintLN_TElementActionTlEdoublegR = { "TElementActionT<double>" , 99 , -1 };
G__linked_taginfo G__PamVMC_fcCintLN_TElementPosActionTlEdoublegR = { "TElementPosActionT<double>" , 99 , -1 };
G__linked_taginfo G__PamVMC_fcCintLN_TMatrixTlEfloatgR = { "TMatrixT<float>" , 99 , -1 };
G__linked_taginfo G__PamVMC_fcCintLN_TMatrixTRow_constlEfloatgR = { "TMatrixTRow_const<float>" , 99 , -1 };
G__linked_taginfo G__PamVMC_fcCintLN_TMatrixTRowlEfloatgR = { "TMatrixTRow<float>" , 99 , -1 };
G__linked_taginfo G__PamVMC_fcCintLN_TMatrixTDiag_constlEfloatgR = { "TMatrixTDiag_const<float>" , 99 , -1 };
G__linked_taginfo G__PamVMC_fcCintLN_TMatrixTColumn_constlEfloatgR = { "TMatrixTColumn_const<float>" , 99 , -1 };
G__linked_taginfo G__PamVMC_fcCintLN_TMatrixTFlat_constlEfloatgR = { "TMatrixTFlat_const<float>" , 99 , -1 };
G__linked_taginfo G__PamVMC_fcCintLN_TMatrixTSub_constlEfloatgR = { "TMatrixTSub_const<float>" , 99 , -1 };
G__linked_taginfo G__PamVMC_fcCintLN_TMatrixTSparseRow_constlEfloatgR = { "TMatrixTSparseRow_const<float>" , 99 , -1 };
G__linked_taginfo G__PamVMC_fcCintLN_TMatrixTSparseDiag_constlEfloatgR = { "TMatrixTSparseDiag_const<float>" , 99 , -1 };
G__linked_taginfo G__PamVMC_fcCintLN_TMatrixTColumnlEfloatgR = { "TMatrixTColumn<float>" , 99 , -1 };
G__linked_taginfo G__PamVMC_fcCintLN_TMatrixTDiaglEfloatgR = { "TMatrixTDiag<float>" , 99 , -1 };
G__linked_taginfo G__PamVMC_fcCintLN_TMatrixTFlatlEfloatgR = { "TMatrixTFlat<float>" , 99 , -1 };
G__linked_taginfo G__PamVMC_fcCintLN_TMatrixTSublEfloatgR = { "TMatrixTSub<float>" , 99 , -1 };
G__linked_taginfo G__PamVMC_fcCintLN_TMatrixTSparseRowlEfloatgR = { "TMatrixTSparseRow<float>" , 99 , -1 };
G__linked_taginfo G__PamVMC_fcCintLN_TMatrixTSparseDiaglEfloatgR = { "TMatrixTSparseDiag<float>" , 99 , -1 };
G__linked_taginfo G__PamVMC_fcCintLN_TVector3 = { "TVector3" , 99 , -1 };
G__linked_taginfo G__PamVMC_fcCintLN_PamVMC2PiAux = { "PamVMC2PiAux" , 99 , -1 };
G__linked_taginfo G__PamVMC_fcCintLN_TVirtualMCApplication = { "TVirtualMCApplication" , 99 , -1 };
G__linked_taginfo G__PamVMC_fcCintLN_TVirtualMCStack = { "TVirtualMCStack" , 99 , -1 };
G__linked_taginfo G__PamVMC_fcCintLN_TMCVerbose = { "TMCVerbose" , 99 , -1 };
G__linked_taginfo G__PamVMC_fcCintLN_TMCProcess = { "TMCProcess" , 101 , -1 };
G__linked_taginfo G__PamVMC_fcCintLN_TVirtualMC = { "TVirtualMC" , 99 , -1 };
G__linked_taginfo G__PamVMC_fcCintLN_TAtt3D = { "TAtt3D" , 99 , -1 };
G__linked_taginfo G__PamVMC_fcCintLN_PamVMCGeoID = { "PamVMCGeoID" , 99 , -1 };
G__linked_taginfo G__PamVMC_fcCintLN_pHitData = { "pHitData" , 99 , -1 };
G__linked_taginfo G__PamVMC_fcCintLN_PamVMCDetectorHit = { "PamVMCDetectorHit" , 99 , -1 };
G__linked_taginfo G__PamVMC_fcCintLN_vectorlETStringcOallocatorlETStringgRsPgR = { "vector<TString,allocator<TString> >" , 99 , -1 };
G__linked_taginfo G__PamVMC_fcCintLN_reverse_iteratorlEvectorlETStringcOallocatorlETStringgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<TString,allocator<TString> >::iterator>" , 99 , -1 };
G__linked_taginfo G__PamVMC_fcCintLN_TRandom3 = { "TRandom3" , 99 , -1 };
G__linked_taginfo G__PamVMC_fcCintLN_pairlEunsignedsPintcOintgR = { "pair<unsigned int,int>" , 115 , -1 };
G__linked_taginfo G__PamVMC_fcCintLN_vectorlEpairlEunsignedsPintcOintgRcOallocatorlEpairlEunsignedsPintcOintgRsPgRsPgR = { "vector<pair<unsigned int,int>,allocator<pair<unsigned int,int> > >" , 99 , -1 };
G__linked_taginfo G__PamVMC_fcCintLN_reverse_iteratorlEvectorlEpairlEunsignedsPintcOintgRcOallocatorlEpairlEunsignedsPintcOintgRsPgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<pair<unsigned int,int>,allocator<pair<unsigned int,int> > >::iterator>" , 99 , -1 };
G__linked_taginfo G__PamVMC_fcCintLN_TF1 = { "TF1" , 99 , -1 };
G__linked_taginfo G__PamVMC_fcCintLN_maplEintcOdoublecOlesslEintgRcOallocatorlEpairlEconstsPintcOdoublegRsPgRsPgR = { "map<int,double,less<int>,allocator<pair<const int,double> > >" , 99 , -1 };
G__linked_taginfo G__PamVMC_fcCintLN_PamVMCSQLMgr = { "PamVMCSQLMgr" , 99 , -1 };
G__linked_taginfo G__PamVMC_fcCintLN_PamVMCRawMgr = { "PamVMCRawMgr" , 99 , -1 };
G__linked_taginfo G__PamVMC_fcCintLN_TXMLNode = { "TXMLNode" , 99 , -1 };
G__linked_taginfo G__PamVMC_fcCintLN_pInitModeOpt = { "pInitModeOpt" , 115 , -1 };
G__linked_taginfo G__PamVMC_fcCintLN_pRandomModeOpt = { "pRandomModeOpt" , 115 , -1 };
G__linked_taginfo G__PamVMC_fcCintLN_Save_cond = { "Save_cond" , 101 , -1 };
G__linked_taginfo G__PamVMC_fcCintLN_Save_mode = { "Save_mode" , 101 , -1 };
G__linked_taginfo G__PamVMC_fcCintLN_pRuntimeModeOpt = { "pRuntimeModeOpt" , 115 , -1 };
G__linked_taginfo G__PamVMC_fcCintLN_Momentum_mode = { "Momentum_mode" , 101 , -1 };
G__linked_taginfo G__PamVMC_fcCintLN_Momentum_units = { "Momentum_units" , 101 , -1 };
G__linked_taginfo G__PamVMC_fcCintLN_Nevents_mode = { "Nevents_mode" , 101 , -1 };
G__linked_taginfo G__PamVMC_fcCintLN_pPrimaryModeOpt = { "pPrimaryModeOpt" , 115 , -1 };
G__linked_taginfo G__PamVMC_fcCintLN_PamVMCOptMgr = { "PamVMCOptMgr" , 99 , -1 };
G__linked_taginfo G__PamVMC_fcCintLN_PamVMCRndMgr = { "PamVMCRndMgr" , 99 , -1 };
G__linked_taginfo G__PamVMC_fcCintLN_PamVMCDigitizer = { "PamVMCDigitizer" , 99 , -1 };
G__linked_taginfo G__PamVMC_fcCintLN_cGPSSPE = { "cGPSSPE" , 115 , -1 };
G__linked_taginfo G__PamVMC_fcCintLN_GPSSPEData = { "GPSSPEData" , 99 , -1 };
G__linked_taginfo G__PamVMC_fcCintLN_pGPSSPEHits = { "pGPSSPEHits" , 99 , -1 };
G__linked_taginfo G__PamVMC_fcCintLN_PamVMCTrkDig = { "PamVMCTrkDig" , 99 , -1 };
G__linked_taginfo G__PamVMC_fcCintLN_PamVMCTofDig = { "PamVMCTofDig" , 99 , -1 };
G__linked_taginfo G__PamVMC_fcCintLN_PamVMCAcDig = { "PamVMCAcDig" , 99 , -1 };
G__linked_taginfo G__PamVMC_fcCintLN_PamVMCCaloDig = { "PamVMCCaloDig" , 99 , -1 };
G__linked_taginfo G__PamVMC_fcCintLN_PamVMCS4Dig = { "PamVMCS4Dig" , 99 , -1 };
G__linked_taginfo G__PamVMC_fcCintLN_vectorlEPamVMCDetectorHitmUcOallocatorlEPamVMCDetectorHitmUgRsPgR = { "vector<PamVMCDetectorHit*,allocator<PamVMCDetectorHit*> >" , 99 , -1 };
G__linked_taginfo G__PamVMC_fcCintLN_reverse_iteratorlEvectorlEPamVMCDetectorHitmUcOallocatorlEPamVMCDetectorHitmUgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<PamVMCDetectorHit*,allocator<PamVMCDetectorHit*> >::iterator>" , 99 , -1 };
G__linked_taginfo G__PamVMC_fcCintLN_PamVMCNDDig = { "PamVMCNDDig" , 99 , -1 };
G__linked_taginfo G__PamVMC_fcCintLN_PamVMCParticle = { "PamVMCParticle" , 99 , -1 };
G__linked_taginfo G__PamVMC_fcCintLN_PamVMCStack = { "PamVMCStack" , 99 , -1 };
G__linked_taginfo G__PamVMC_fcCintLN_dequelEPamVMCParticlemUcOallocatorlEPamVMCParticlemUgRsPgR = { "deque<PamVMCParticle*,allocator<PamVMCParticle*> >" , 99 , -1 };
G__linked_taginfo G__PamVMC_fcCintLN_stacklEPamVMCParticlemUcOdequelEPamVMCParticlemUcOallocatorlEPamVMCParticlemUgRsPgRsPgR = { "stack<PamVMCParticle*,deque<PamVMCParticle*,allocator<PamVMCParticle*> > >" , 99 , -1 };
G__linked_taginfo G__PamVMC_fcCintLN_fin = { "fin" , 101 , -1 };
G__linked_taginfo G__PamVMC_fcCintLN_PamVMCDetectorSD = { "PamVMCDetectorSD" , 99 , -1 };
G__linked_taginfo G__PamVMC_fcCintLN_maplEconstsPpamelacLcLPacketTypemUcOTTreemUcOlesslEconstsPpamelacLcLPacketTypemUgRcOallocatorlEpairlEconstsPpamelacLcLPacketTypemUsPconstcOTTreemUgRsPgRsPgR = { "map<const pamela::PacketType*,TTree*,less<const pamela::PacketType*>,allocator<pair<const pamela::PacketType* const,TTree*> > >" , 99 , -1 };
G__linked_taginfo G__PamVMC_fcCintLN_listlETFilemUcOallocatorlETFilemUgRsPgR = { "list<TFile*,allocator<TFile*> >" , 99 , -1 };
G__linked_taginfo G__PamVMC_fcCintLN_listlETTreemUcOallocatorlETTreemUgRsPgR = { "list<TTree*,allocator<TTree*> >" , 99 , -1 };
G__linked_taginfo G__PamVMC_fcCintLN_maplEconstsPpamelacLcLPacketTypemUcOlistlETTreemUcOallocatorlETTreemUgRsPgRcOlesslEconstsPpamelacLcLPacketTypemUgRcOallocatorlEpairlEconstsPpamelacLcLPacketTypemUsPconstcOlistlETTreemUcOallocatorlETTreemUgRsPgRsPgRsPgRsPgR = { "map<const pamela::PacketType*,list<TTree*,allocator<TTree*> >,less<const pamela::PacketType*>,allocator<pair<const pamela::PacketType* const,list<TTree*,allocator<TTree*> > > > >" , 99 , -1 };
G__linked_taginfo G__PamVMC_fcCintLN_maplEstringcOpamelacLcLSubPacketmUcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOpamelacLcLSubPacketmUgRsPgRsPgR = { "map<string,pamela::SubPacket*,less<string>,allocator<pair<const string,pamela::SubPacket*> > >" , 99 , -1 };
G__linked_taginfo G__PamVMC_fcCintLN_TMatrixTlEdoublegR = { "TMatrixT<double>" , 99 , -1 };
G__linked_taginfo G__PamVMC_fcCintLN_TMatrixTRow_constlEdoublegR = { "TMatrixTRow_const<double>" , 99 , -1 };
G__linked_taginfo G__PamVMC_fcCintLN_TMatrixTRowlEdoublegR = { "TMatrixTRow<double>" , 99 , -1 };
G__linked_taginfo G__PamVMC_fcCintLN_TMatrixTDiag_constlEdoublegR = { "TMatrixTDiag_const<double>" , 99 , -1 };
G__linked_taginfo G__PamVMC_fcCintLN_TMatrixTColumn_constlEdoublegR = { "TMatrixTColumn_const<double>" , 99 , -1 };
G__linked_taginfo G__PamVMC_fcCintLN_TMatrixTFlat_constlEdoublegR = { "TMatrixTFlat_const<double>" , 99 , -1 };
G__linked_taginfo G__PamVMC_fcCintLN_TMatrixTSub_constlEdoublegR = { "TMatrixTSub_const<double>" , 99 , -1 };
G__linked_taginfo G__PamVMC_fcCintLN_TMatrixTSparseRow_constlEdoublegR = { "TMatrixTSparseRow_const<double>" , 99 , -1 };
G__linked_taginfo G__PamVMC_fcCintLN_TMatrixTSparseDiag_constlEdoublegR = { "TMatrixTSparseDiag_const<double>" , 99 , -1 };
G__linked_taginfo G__PamVMC_fcCintLN_TMatrixTColumnlEdoublegR = { "TMatrixTColumn<double>" , 99 , -1 };
G__linked_taginfo G__PamVMC_fcCintLN_TMatrixTDiaglEdoublegR = { "TMatrixTDiag<double>" , 99 , -1 };
G__linked_taginfo G__PamVMC_fcCintLN_TMatrixTFlatlEdoublegR = { "TMatrixTFlat<double>" , 99 , -1 };
G__linked_taginfo G__PamVMC_fcCintLN_TMatrixTSublEdoublegR = { "TMatrixTSub<double>" , 99 , -1 };
G__linked_taginfo G__PamVMC_fcCintLN_TMatrixTSparseRowlEdoublegR = { "TMatrixTSparseRow<double>" , 99 , -1 };
G__linked_taginfo G__PamVMC_fcCintLN_TMatrixTSparseDiaglEdoublegR = { "TMatrixTSparseDiag<double>" , 99 , -1 };
G__linked_taginfo G__PamVMC_fcCintLN_vectorlEPamVMCPlCrossmUcOallocatorlEPamVMCPlCrossmUgRsPgR = { "vector<PamVMCPlCross*,allocator<PamVMCPlCross*> >" , 99 , -1 };
G__linked_taginfo G__PamVMC_fcCintLN_reverse_iteratorlEvectorlEPamVMCPlCrossmUcOallocatorlEPamVMCPlCrossmUgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<PamVMCPlCross*,allocator<PamVMCPlCross*> >::iterator>" , 99 , -1 };
G__linked_taginfo G__PamVMC_fcCintLN_PamVMCPrimaryGF = { "PamVMCPrimaryGF" , 99 , -1 };
G__linked_taginfo G__PamVMC_fcCintLN_PamVMCPrimary = { "PamVMCPrimary" , 99 , -1 };
G__linked_taginfo G__PamVMC_fcCintLN_PamVMCPrimaryGenerator = { "PamVMCPrimaryGenerator" , 99 , -1 };
G__linked_taginfo G__PamVMC_fcCintLN_maplEintcOTGeoElementRNmUcOlesslEintgRcOallocatorlEpairlEconstsPintcOTGeoElementRNmUgRsPgRsPgR = { "map<int,TGeoElementRN*,less<int>,allocator<pair<const int,TGeoElementRN*> > >" , 99 , -1 };
G__linked_taginfo G__PamVMC_fcCintLN_TGeoMaterial = { "TGeoMaterial" , 99 , -1 };
G__linked_taginfo G__PamVMC_fcCintLN_TGeoMedium = { "TGeoMedium" , 99 , -1 };
G__linked_taginfo G__PamVMC_fcCintLN_TGeoMatrix = { "TGeoMatrix" , 99 , -1 };
G__linked_taginfo G__PamVMC_fcCintLN_TGeoVolume = { "TGeoVolume" , 99 , -1 };
G__linked_taginfo G__PamVMC_fcCintLN_vectorlETGeoVolumeAssemblycLcLThreadData_tmUcOallocatorlETGeoVolumeAssemblycLcLThreadData_tmUgRsPgR = { "vector<TGeoVolumeAssembly::ThreadData_t*,allocator<TGeoVolumeAssembly::ThreadData_t*> >" , 99 , -1 };
G__linked_taginfo G__PamVMC_fcCintLN_reverse_iteratorlEvectorlETGeoVolumeAssemblycLcLThreadData_tmUcOallocatorlETGeoVolumeAssemblycLcLThreadData_tmUgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<TGeoVolumeAssembly::ThreadData_t*,allocator<TGeoVolumeAssembly::ThreadData_t*> >::iterator>" , 99 , -1 };
G__linked_taginfo G__PamVMC_fcCintLN_TGeoRotation = { "TGeoRotation" , 99 , -1 };
G__linked_taginfo G__PamVMC_fcCintLN_maplElongcOTGeoNavigatorArraymUcOlesslElonggRcOallocatorlEpairlEconstsPlongcOTGeoNavigatorArraymUgRsPgRsPgR = { "map<long,TGeoNavigatorArray*,less<long>,allocator<pair<const long,TGeoNavigatorArray*> > >" , 99 , -1 };
G__linked_taginfo G__PamVMC_fcCintLN_pCutControl = { "pCutControl" , 99 , -1 };
G__linked_taginfo G__PamVMC_fcCintLN_pMotherProp = { "pMotherProp" , 115 , -1 };
G__linked_taginfo G__PamVMC_fcCintLN_PamVMCDetGeom = { "PamVMCDetGeom" , 99 , -1 };
G__linked_taginfo G__PamVMC_fcCintLN_PamVMCDetGeomcLcLkind = { "PamVMCDetGeom::kind" , 101 , -1 };
G__linked_taginfo G__PamVMC_fcCintLN_PamVMCDetector = { "PamVMCDetector" , 99 , -1 };
G__linked_taginfo G__PamVMC_fcCintLN_PamVMCCaloSD = { "PamVMCCaloSD" , 99 , -1 };
G__linked_taginfo G__PamVMC_fcCintLN_PamVMCDetCalo = { "PamVMCDetCalo" , 99 , -1 };
G__linked_taginfo G__PamVMC_fcCintLN_maplEintcOpCombTransmUcOlesslEintgRcOallocatorlEpairlEconstsPintcOpCombTransmUgRsPgRsPgR = { "map<int,pCombTrans*,less<int>,allocator<pair<const int,pCombTrans*> > >" , 99 , -1 };
G__linked_taginfo G__PamVMC_fcCintLN_pTrkHitData = { "pTrkHitData" , 99 , -1 };
G__linked_taginfo G__PamVMC_fcCintLN_PamVMCTrkHit = { "PamVMCTrkHit" , 99 , -1 };
G__linked_taginfo G__PamVMC_fcCintLN_cGPCSPE = { "cGPCSPE" , 115 , -1 };
G__linked_taginfo G__PamVMC_fcCintLN_PamVMCTrkSD = { "PamVMCTrkSD" , 99 , -1 };
G__linked_taginfo G__PamVMC_fcCintLN_PamVMCDetTrk = { "PamVMCDetTrk" , 99 , -1 };
G__linked_taginfo G__PamVMC_fcCintLN_PamVMCTofSD = { "PamVMCTofSD" , 99 , -1 };
G__linked_taginfo G__PamVMC_fcCintLN_PamVMCDetTofS1 = { "PamVMCDetTofS1" , 99 , -1 };
G__linked_taginfo G__PamVMC_fcCintLN_PamVMCDetTofS2 = { "PamVMCDetTofS2" , 99 , -1 };
G__linked_taginfo G__PamVMC_fcCintLN_PamVMCDetTofS3 = { "PamVMCDetTofS3" , 99 , -1 };
G__linked_taginfo G__PamVMC_fcCintLN_PamVMCDetTof = { "PamVMCDetTof" , 99 , -1 };
G__linked_taginfo G__PamVMC_fcCintLN_PamVMCCardSD = { "PamVMCCardSD" , 99 , -1 };
G__linked_taginfo G__PamVMC_fcCintLN_PamVMCDetCard = { "PamVMCDetCard" , 99 , -1 };
G__linked_taginfo G__PamVMC_fcCintLN_PamVMCCasSD = { "PamVMCCasSD" , 99 , -1 };
G__linked_taginfo G__PamVMC_fcCintLN_PamVMCDetCas = { "PamVMCDetCas" , 99 , -1 };
G__linked_taginfo G__PamVMC_fcCintLN_PamVMCCatSD = { "PamVMCCatSD" , 99 , -1 };
G__linked_taginfo G__PamVMC_fcCintLN_PamVMCDetCat = { "PamVMCDetCat" , 99 , -1 };
G__linked_taginfo G__PamVMC_fcCintLN_PamVMCDetAc = { "PamVMCDetAc" , 99 , -1 };
G__linked_taginfo G__PamVMC_fcCintLN_PamVMCS4SD = { "PamVMCS4SD" , 99 , -1 };
G__linked_taginfo G__PamVMC_fcCintLN_PamVMCDetS4 = { "PamVMCDetS4" , 99 , -1 };
G__linked_taginfo G__PamVMC_fcCintLN_PamVMCNDSD = { "PamVMCNDSD" , 99 , -1 };
G__linked_taginfo G__PamVMC_fcCintLN_PamVMCDetND = { "PamVMCDetND" , 99 , -1 };
G__linked_taginfo G__PamVMC_fcCintLN_PamVMCDetPamela = { "PamVMCDetPamela" , 99 , -1 };
G__linked_taginfo G__PamVMC_fcCintLN_PamVMCApplication = { "PamVMCApplication" , 99 , -1 };

/* Reset class/struct taginfo */
extern "C" void G__cpp_reset_tagtablePamVMC_fcCint() {
  G__PamVMC_fcCintLN_TClass.tagnum = -1 ;
  G__PamVMC_fcCintLN_TBuffer.tagnum = -1 ;
  G__PamVMC_fcCintLN_TDirectory.tagnum = -1 ;
  G__PamVMC_fcCintLN_TMemberInspector.tagnum = -1 ;
  G__PamVMC_fcCintLN_TObject.tagnum = -1 ;
  G__PamVMC_fcCintLN_TNamed.tagnum = -1 ;
  G__PamVMC_fcCintLN_TString.tagnum = -1 ;
  G__PamVMC_fcCintLN_vectorlEunsignedsPcharcOallocatorlEunsignedsPchargRsPgR.tagnum = -1 ;
  G__PamVMC_fcCintLN_vectorlEunsignedsPshortcOallocatorlEunsignedsPshortgRsPgR.tagnum = -1 ;
  G__PamVMC_fcCintLN_vectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgR.tagnum = -1 ;
  G__PamVMC_fcCintLN_vectorlEdoublecOallocatorlEdoublegRsPgR.tagnum = -1 ;
  G__PamVMC_fcCintLN_basic_ifstreamlEcharcOchar_traitslEchargRsPgR.tagnum = -1 ;
  G__PamVMC_fcCintLN_basic_stringstreamlEcharcOchar_traitslEchargRcOallocatorlEchargRsPgR.tagnum = -1 ;
  G__PamVMC_fcCintLN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR.tagnum = -1 ;
  G__PamVMC_fcCintLN_reverse_iteratorlEvectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__PamVMC_fcCintLN_TObjArray.tagnum = -1 ;
  G__PamVMC_fcCintLN_TClonesArray.tagnum = -1 ;
  G__PamVMC_fcCintLN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR.tagnum = -1 ;
  G__PamVMC_fcCintLN_reverse_iteratorlEvectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__PamVMC_fcCintLN_iteratorlEbidirectional_iterator_tagcOTObjectmUcOlongcOconstsPTObjectmUmUcOconstsPTObjectmUaNgR.tagnum = -1 ;
  G__PamVMC_fcCintLN_TTree.tagnum = -1 ;
  G__PamVMC_fcCintLN_TFile.tagnum = -1 ;
  G__PamVMC_fcCintLN_TAttLine.tagnum = -1 ;
  G__PamVMC_fcCintLN_maplElongcOintcOlesslElonggRcOallocatorlEpairlEconstsPlongcOintgRsPgRsPgR.tagnum = -1 ;
  G__PamVMC_fcCintLN_maplEstringcOTObjArraymUcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOTObjArraymUgRsPgRsPgR.tagnum = -1 ;
  G__PamVMC_fcCintLN_TMap.tagnum = -1 ;
  G__PamVMC_fcCintLN_TParticle.tagnum = -1 ;
  G__PamVMC_fcCintLN_FileMode.tagnum = -1 ;
  G__PamVMC_fcCintLN_PamRootManager.tagnum = -1 ;
  G__PamVMC_fcCintLN_TRandom.tagnum = -1 ;
  G__PamVMC_fcCintLN_TVector2.tagnum = -1 ;
  G__PamVMC_fcCintLN_TMatrixTBaselEfloatgR.tagnum = -1 ;
  G__PamVMC_fcCintLN_TMatrixTBaselEdoublegR.tagnum = -1 ;
  G__PamVMC_fcCintLN_TVectorTlEfloatgR.tagnum = -1 ;
  G__PamVMC_fcCintLN_TVectorTlEdoublegR.tagnum = -1 ;
  G__PamVMC_fcCintLN_TElementActionTlEfloatgR.tagnum = -1 ;
  G__PamVMC_fcCintLN_TElementPosActionTlEfloatgR.tagnum = -1 ;
  G__PamVMC_fcCintLN_TElementActionTlEdoublegR.tagnum = -1 ;
  G__PamVMC_fcCintLN_TElementPosActionTlEdoublegR.tagnum = -1 ;
  G__PamVMC_fcCintLN_TMatrixTlEfloatgR.tagnum = -1 ;
  G__PamVMC_fcCintLN_TMatrixTRow_constlEfloatgR.tagnum = -1 ;
  G__PamVMC_fcCintLN_TMatrixTRowlEfloatgR.tagnum = -1 ;
  G__PamVMC_fcCintLN_TMatrixTDiag_constlEfloatgR.tagnum = -1 ;
  G__PamVMC_fcCintLN_TMatrixTColumn_constlEfloatgR.tagnum = -1 ;
  G__PamVMC_fcCintLN_TMatrixTFlat_constlEfloatgR.tagnum = -1 ;
  G__PamVMC_fcCintLN_TMatrixTSub_constlEfloatgR.tagnum = -1 ;
  G__PamVMC_fcCintLN_TMatrixTSparseRow_constlEfloatgR.tagnum = -1 ;
  G__PamVMC_fcCintLN_TMatrixTSparseDiag_constlEfloatgR.tagnum = -1 ;
  G__PamVMC_fcCintLN_TMatrixTColumnlEfloatgR.tagnum = -1 ;
  G__PamVMC_fcCintLN_TMatrixTDiaglEfloatgR.tagnum = -1 ;
  G__PamVMC_fcCintLN_TMatrixTFlatlEfloatgR.tagnum = -1 ;
  G__PamVMC_fcCintLN_TMatrixTSublEfloatgR.tagnum = -1 ;
  G__PamVMC_fcCintLN_TMatrixTSparseRowlEfloatgR.tagnum = -1 ;
  G__PamVMC_fcCintLN_TMatrixTSparseDiaglEfloatgR.tagnum = -1 ;
  G__PamVMC_fcCintLN_TVector3.tagnum = -1 ;
  G__PamVMC_fcCintLN_PamVMC2PiAux.tagnum = -1 ;
  G__PamVMC_fcCintLN_TVirtualMCApplication.tagnum = -1 ;
  G__PamVMC_fcCintLN_TVirtualMCStack.tagnum = -1 ;
  G__PamVMC_fcCintLN_TMCVerbose.tagnum = -1 ;
  G__PamVMC_fcCintLN_TMCProcess.tagnum = -1 ;
  G__PamVMC_fcCintLN_TVirtualMC.tagnum = -1 ;
  G__PamVMC_fcCintLN_TAtt3D.tagnum = -1 ;
  G__PamVMC_fcCintLN_PamVMCGeoID.tagnum = -1 ;
  G__PamVMC_fcCintLN_pHitData.tagnum = -1 ;
  G__PamVMC_fcCintLN_PamVMCDetectorHit.tagnum = -1 ;
  G__PamVMC_fcCintLN_vectorlETStringcOallocatorlETStringgRsPgR.tagnum = -1 ;
  G__PamVMC_fcCintLN_reverse_iteratorlEvectorlETStringcOallocatorlETStringgRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__PamVMC_fcCintLN_TRandom3.tagnum = -1 ;
  G__PamVMC_fcCintLN_pairlEunsignedsPintcOintgR.tagnum = -1 ;
  G__PamVMC_fcCintLN_vectorlEpairlEunsignedsPintcOintgRcOallocatorlEpairlEunsignedsPintcOintgRsPgRsPgR.tagnum = -1 ;
  G__PamVMC_fcCintLN_reverse_iteratorlEvectorlEpairlEunsignedsPintcOintgRcOallocatorlEpairlEunsignedsPintcOintgRsPgRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__PamVMC_fcCintLN_TF1.tagnum = -1 ;
  G__PamVMC_fcCintLN_maplEintcOdoublecOlesslEintgRcOallocatorlEpairlEconstsPintcOdoublegRsPgRsPgR.tagnum = -1 ;
  G__PamVMC_fcCintLN_PamVMCSQLMgr.tagnum = -1 ;
  G__PamVMC_fcCintLN_PamVMCRawMgr.tagnum = -1 ;
  G__PamVMC_fcCintLN_TXMLNode.tagnum = -1 ;
  G__PamVMC_fcCintLN_pInitModeOpt.tagnum = -1 ;
  G__PamVMC_fcCintLN_pRandomModeOpt.tagnum = -1 ;
  G__PamVMC_fcCintLN_Save_cond.tagnum = -1 ;
  G__PamVMC_fcCintLN_Save_mode.tagnum = -1 ;
  G__PamVMC_fcCintLN_pRuntimeModeOpt.tagnum = -1 ;
  G__PamVMC_fcCintLN_Momentum_mode.tagnum = -1 ;
  G__PamVMC_fcCintLN_Momentum_units.tagnum = -1 ;
  G__PamVMC_fcCintLN_Nevents_mode.tagnum = -1 ;
  G__PamVMC_fcCintLN_pPrimaryModeOpt.tagnum = -1 ;
  G__PamVMC_fcCintLN_PamVMCOptMgr.tagnum = -1 ;
  G__PamVMC_fcCintLN_PamVMCRndMgr.tagnum = -1 ;
  G__PamVMC_fcCintLN_PamVMCDigitizer.tagnum = -1 ;
  G__PamVMC_fcCintLN_cGPSSPE.tagnum = -1 ;
  G__PamVMC_fcCintLN_GPSSPEData.tagnum = -1 ;
  G__PamVMC_fcCintLN_pGPSSPEHits.tagnum = -1 ;
  G__PamVMC_fcCintLN_PamVMCTrkDig.tagnum = -1 ;
  G__PamVMC_fcCintLN_PamVMCTofDig.tagnum = -1 ;
  G__PamVMC_fcCintLN_PamVMCAcDig.tagnum = -1 ;
  G__PamVMC_fcCintLN_PamVMCCaloDig.tagnum = -1 ;
  G__PamVMC_fcCintLN_PamVMCS4Dig.tagnum = -1 ;
  G__PamVMC_fcCintLN_vectorlEPamVMCDetectorHitmUcOallocatorlEPamVMCDetectorHitmUgRsPgR.tagnum = -1 ;
  G__PamVMC_fcCintLN_reverse_iteratorlEvectorlEPamVMCDetectorHitmUcOallocatorlEPamVMCDetectorHitmUgRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__PamVMC_fcCintLN_PamVMCNDDig.tagnum = -1 ;
  G__PamVMC_fcCintLN_PamVMCParticle.tagnum = -1 ;
  G__PamVMC_fcCintLN_PamVMCStack.tagnum = -1 ;
  G__PamVMC_fcCintLN_dequelEPamVMCParticlemUcOallocatorlEPamVMCParticlemUgRsPgR.tagnum = -1 ;
  G__PamVMC_fcCintLN_stacklEPamVMCParticlemUcOdequelEPamVMCParticlemUcOallocatorlEPamVMCParticlemUgRsPgRsPgR.tagnum = -1 ;
  G__PamVMC_fcCintLN_fin.tagnum = -1 ;
  G__PamVMC_fcCintLN_PamVMCDetectorSD.tagnum = -1 ;
  G__PamVMC_fcCintLN_maplEconstsPpamelacLcLPacketTypemUcOTTreemUcOlesslEconstsPpamelacLcLPacketTypemUgRcOallocatorlEpairlEconstsPpamelacLcLPacketTypemUsPconstcOTTreemUgRsPgRsPgR.tagnum = -1 ;
  G__PamVMC_fcCintLN_listlETFilemUcOallocatorlETFilemUgRsPgR.tagnum = -1 ;
  G__PamVMC_fcCintLN_listlETTreemUcOallocatorlETTreemUgRsPgR.tagnum = -1 ;
  G__PamVMC_fcCintLN_maplEconstsPpamelacLcLPacketTypemUcOlistlETTreemUcOallocatorlETTreemUgRsPgRcOlesslEconstsPpamelacLcLPacketTypemUgRcOallocatorlEpairlEconstsPpamelacLcLPacketTypemUsPconstcOlistlETTreemUcOallocatorlETTreemUgRsPgRsPgRsPgRsPgR.tagnum = -1 ;
  G__PamVMC_fcCintLN_maplEstringcOpamelacLcLSubPacketmUcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOpamelacLcLSubPacketmUgRsPgRsPgR.tagnum = -1 ;
  G__PamVMC_fcCintLN_TMatrixTlEdoublegR.tagnum = -1 ;
  G__PamVMC_fcCintLN_TMatrixTRow_constlEdoublegR.tagnum = -1 ;
  G__PamVMC_fcCintLN_TMatrixTRowlEdoublegR.tagnum = -1 ;
  G__PamVMC_fcCintLN_TMatrixTDiag_constlEdoublegR.tagnum = -1 ;
  G__PamVMC_fcCintLN_TMatrixTColumn_constlEdoublegR.tagnum = -1 ;
  G__PamVMC_fcCintLN_TMatrixTFlat_constlEdoublegR.tagnum = -1 ;
  G__PamVMC_fcCintLN_TMatrixTSub_constlEdoublegR.tagnum = -1 ;
  G__PamVMC_fcCintLN_TMatrixTSparseRow_constlEdoublegR.tagnum = -1 ;
  G__PamVMC_fcCintLN_TMatrixTSparseDiag_constlEdoublegR.tagnum = -1 ;
  G__PamVMC_fcCintLN_TMatrixTColumnlEdoublegR.tagnum = -1 ;
  G__PamVMC_fcCintLN_TMatrixTDiaglEdoublegR.tagnum = -1 ;
  G__PamVMC_fcCintLN_TMatrixTFlatlEdoublegR.tagnum = -1 ;
  G__PamVMC_fcCintLN_TMatrixTSublEdoublegR.tagnum = -1 ;
  G__PamVMC_fcCintLN_TMatrixTSparseRowlEdoublegR.tagnum = -1 ;
  G__PamVMC_fcCintLN_TMatrixTSparseDiaglEdoublegR.tagnum = -1 ;
  G__PamVMC_fcCintLN_vectorlEPamVMCPlCrossmUcOallocatorlEPamVMCPlCrossmUgRsPgR.tagnum = -1 ;
  G__PamVMC_fcCintLN_reverse_iteratorlEvectorlEPamVMCPlCrossmUcOallocatorlEPamVMCPlCrossmUgRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__PamVMC_fcCintLN_PamVMCPrimaryGF.tagnum = -1 ;
  G__PamVMC_fcCintLN_PamVMCPrimary.tagnum = -1 ;
  G__PamVMC_fcCintLN_PamVMCPrimaryGenerator.tagnum = -1 ;
  G__PamVMC_fcCintLN_maplEintcOTGeoElementRNmUcOlesslEintgRcOallocatorlEpairlEconstsPintcOTGeoElementRNmUgRsPgRsPgR.tagnum = -1 ;
  G__PamVMC_fcCintLN_TGeoMaterial.tagnum = -1 ;
  G__PamVMC_fcCintLN_TGeoMedium.tagnum = -1 ;
  G__PamVMC_fcCintLN_TGeoMatrix.tagnum = -1 ;
  G__PamVMC_fcCintLN_TGeoVolume.tagnum = -1 ;
  G__PamVMC_fcCintLN_vectorlETGeoVolumeAssemblycLcLThreadData_tmUcOallocatorlETGeoVolumeAssemblycLcLThreadData_tmUgRsPgR.tagnum = -1 ;
  G__PamVMC_fcCintLN_reverse_iteratorlEvectorlETGeoVolumeAssemblycLcLThreadData_tmUcOallocatorlETGeoVolumeAssemblycLcLThreadData_tmUgRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__PamVMC_fcCintLN_TGeoRotation.tagnum = -1 ;
  G__PamVMC_fcCintLN_maplElongcOTGeoNavigatorArraymUcOlesslElonggRcOallocatorlEpairlEconstsPlongcOTGeoNavigatorArraymUgRsPgRsPgR.tagnum = -1 ;
  G__PamVMC_fcCintLN_pCutControl.tagnum = -1 ;
  G__PamVMC_fcCintLN_pMotherProp.tagnum = -1 ;
  G__PamVMC_fcCintLN_PamVMCDetGeom.tagnum = -1 ;
  G__PamVMC_fcCintLN_PamVMCDetGeomcLcLkind.tagnum = -1 ;
  G__PamVMC_fcCintLN_PamVMCDetector.tagnum = -1 ;
  G__PamVMC_fcCintLN_PamVMCCaloSD.tagnum = -1 ;
  G__PamVMC_fcCintLN_PamVMCDetCalo.tagnum = -1 ;
  G__PamVMC_fcCintLN_maplEintcOpCombTransmUcOlesslEintgRcOallocatorlEpairlEconstsPintcOpCombTransmUgRsPgRsPgR.tagnum = -1 ;
  G__PamVMC_fcCintLN_pTrkHitData.tagnum = -1 ;
  G__PamVMC_fcCintLN_PamVMCTrkHit.tagnum = -1 ;
  G__PamVMC_fcCintLN_cGPCSPE.tagnum = -1 ;
  G__PamVMC_fcCintLN_PamVMCTrkSD.tagnum = -1 ;
  G__PamVMC_fcCintLN_PamVMCDetTrk.tagnum = -1 ;
  G__PamVMC_fcCintLN_PamVMCTofSD.tagnum = -1 ;
  G__PamVMC_fcCintLN_PamVMCDetTofS1.tagnum = -1 ;
  G__PamVMC_fcCintLN_PamVMCDetTofS2.tagnum = -1 ;
  G__PamVMC_fcCintLN_PamVMCDetTofS3.tagnum = -1 ;
  G__PamVMC_fcCintLN_PamVMCDetTof.tagnum = -1 ;
  G__PamVMC_fcCintLN_PamVMCCardSD.tagnum = -1 ;
  G__PamVMC_fcCintLN_PamVMCDetCard.tagnum = -1 ;
  G__PamVMC_fcCintLN_PamVMCCasSD.tagnum = -1 ;
  G__PamVMC_fcCintLN_PamVMCDetCas.tagnum = -1 ;
  G__PamVMC_fcCintLN_PamVMCCatSD.tagnum = -1 ;
  G__PamVMC_fcCintLN_PamVMCDetCat.tagnum = -1 ;
  G__PamVMC_fcCintLN_PamVMCDetAc.tagnum = -1 ;
  G__PamVMC_fcCintLN_PamVMCS4SD.tagnum = -1 ;
  G__PamVMC_fcCintLN_PamVMCDetS4.tagnum = -1 ;
  G__PamVMC_fcCintLN_PamVMCNDSD.tagnum = -1 ;
  G__PamVMC_fcCintLN_PamVMCDetND.tagnum = -1 ;
  G__PamVMC_fcCintLN_PamVMCDetPamela.tagnum = -1 ;
  G__PamVMC_fcCintLN_PamVMCApplication.tagnum = -1 ;
}


extern "C" void G__cpp_setup_tagtablePamVMC_fcCint() {

   /* Setting up class,struct,union tag entry */
   G__get_linked_tagnum_fwd(&G__PamVMC_fcCintLN_TClass);
   G__get_linked_tagnum_fwd(&G__PamVMC_fcCintLN_TBuffer);
   G__get_linked_tagnum_fwd(&G__PamVMC_fcCintLN_TDirectory);
   G__get_linked_tagnum_fwd(&G__PamVMC_fcCintLN_TMemberInspector);
   G__get_linked_tagnum_fwd(&G__PamVMC_fcCintLN_TObject);
   G__get_linked_tagnum_fwd(&G__PamVMC_fcCintLN_TNamed);
   G__get_linked_tagnum_fwd(&G__PamVMC_fcCintLN_TString);
   G__get_linked_tagnum_fwd(&G__PamVMC_fcCintLN_vectorlEunsignedsPcharcOallocatorlEunsignedsPchargRsPgR);
   G__get_linked_tagnum_fwd(&G__PamVMC_fcCintLN_vectorlEunsignedsPshortcOallocatorlEunsignedsPshortgRsPgR);
   G__get_linked_tagnum_fwd(&G__PamVMC_fcCintLN_vectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgR);
   G__get_linked_tagnum_fwd(&G__PamVMC_fcCintLN_vectorlEdoublecOallocatorlEdoublegRsPgR);
   G__get_linked_tagnum_fwd(&G__PamVMC_fcCintLN_basic_ifstreamlEcharcOchar_traitslEchargRsPgR);
   G__get_linked_tagnum_fwd(&G__PamVMC_fcCintLN_basic_stringstreamlEcharcOchar_traitslEchargRcOallocatorlEchargRsPgR);
   G__get_linked_tagnum_fwd(&G__PamVMC_fcCintLN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR);
   G__get_linked_tagnum_fwd(&G__PamVMC_fcCintLN_reverse_iteratorlEvectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgRcLcLiteratorgR);
   G__get_linked_tagnum_fwd(&G__PamVMC_fcCintLN_TObjArray);
   G__get_linked_tagnum_fwd(&G__PamVMC_fcCintLN_TClonesArray);
   G__get_linked_tagnum_fwd(&G__PamVMC_fcCintLN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR);
   G__get_linked_tagnum_fwd(&G__PamVMC_fcCintLN_reverse_iteratorlEvectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgRcLcLiteratorgR);
   G__get_linked_tagnum_fwd(&G__PamVMC_fcCintLN_iteratorlEbidirectional_iterator_tagcOTObjectmUcOlongcOconstsPTObjectmUmUcOconstsPTObjectmUaNgR);
   G__get_linked_tagnum_fwd(&G__PamVMC_fcCintLN_TTree);
   G__get_linked_tagnum_fwd(&G__PamVMC_fcCintLN_TFile);
   G__get_linked_tagnum_fwd(&G__PamVMC_fcCintLN_TAttLine);
   G__get_linked_tagnum_fwd(&G__PamVMC_fcCintLN_maplElongcOintcOlesslElonggRcOallocatorlEpairlEconstsPlongcOintgRsPgRsPgR);
   G__get_linked_tagnum_fwd(&G__PamVMC_fcCintLN_maplEstringcOTObjArraymUcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOTObjArraymUgRsPgRsPgR);
   G__get_linked_tagnum_fwd(&G__PamVMC_fcCintLN_TMap);
   G__get_linked_tagnum_fwd(&G__PamVMC_fcCintLN_TParticle);
   G__get_linked_tagnum_fwd(&G__PamVMC_fcCintLN_FileMode);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__PamVMC_fcCintLN_PamRootManager),sizeof(PamRootManager),-1,324864,"Root IO manager",G__setup_memvarPamRootManager,G__setup_memfuncPamRootManager);
   G__get_linked_tagnum_fwd(&G__PamVMC_fcCintLN_TRandom);
   G__get_linked_tagnum_fwd(&G__PamVMC_fcCintLN_TVector2);
   G__get_linked_tagnum_fwd(&G__PamVMC_fcCintLN_TMatrixTBaselEfloatgR);
   G__get_linked_tagnum_fwd(&G__PamVMC_fcCintLN_TMatrixTBaselEdoublegR);
   G__get_linked_tagnum_fwd(&G__PamVMC_fcCintLN_TVectorTlEfloatgR);
   G__get_linked_tagnum_fwd(&G__PamVMC_fcCintLN_TVectorTlEdoublegR);
   G__get_linked_tagnum_fwd(&G__PamVMC_fcCintLN_TElementActionTlEfloatgR);
   G__get_linked_tagnum_fwd(&G__PamVMC_fcCintLN_TElementPosActionTlEfloatgR);
   G__get_linked_tagnum_fwd(&G__PamVMC_fcCintLN_TElementActionTlEdoublegR);
   G__get_linked_tagnum_fwd(&G__PamVMC_fcCintLN_TElementPosActionTlEdoublegR);
   G__get_linked_tagnum_fwd(&G__PamVMC_fcCintLN_TMatrixTlEfloatgR);
   G__get_linked_tagnum_fwd(&G__PamVMC_fcCintLN_TMatrixTRow_constlEfloatgR);
   G__get_linked_tagnum_fwd(&G__PamVMC_fcCintLN_TMatrixTRowlEfloatgR);
   G__get_linked_tagnum_fwd(&G__PamVMC_fcCintLN_TMatrixTDiag_constlEfloatgR);
   G__get_linked_tagnum_fwd(&G__PamVMC_fcCintLN_TMatrixTColumn_constlEfloatgR);
   G__get_linked_tagnum_fwd(&G__PamVMC_fcCintLN_TMatrixTFlat_constlEfloatgR);
   G__get_linked_tagnum_fwd(&G__PamVMC_fcCintLN_TMatrixTSub_constlEfloatgR);
   G__get_linked_tagnum_fwd(&G__PamVMC_fcCintLN_TMatrixTSparseRow_constlEfloatgR);
   G__get_linked_tagnum_fwd(&G__PamVMC_fcCintLN_TMatrixTSparseDiag_constlEfloatgR);
   G__get_linked_tagnum_fwd(&G__PamVMC_fcCintLN_TMatrixTColumnlEfloatgR);
   G__get_linked_tagnum_fwd(&G__PamVMC_fcCintLN_TMatrixTDiaglEfloatgR);
   G__get_linked_tagnum_fwd(&G__PamVMC_fcCintLN_TMatrixTFlatlEfloatgR);
   G__get_linked_tagnum_fwd(&G__PamVMC_fcCintLN_TMatrixTSublEfloatgR);
   G__get_linked_tagnum_fwd(&G__PamVMC_fcCintLN_TMatrixTSparseRowlEfloatgR);
   G__get_linked_tagnum_fwd(&G__PamVMC_fcCintLN_TMatrixTSparseDiaglEfloatgR);
   G__get_linked_tagnum_fwd(&G__PamVMC_fcCintLN_TVector3);
   G__get_linked_tagnum_fwd(&G__PamVMC_fcCintLN_PamVMC2PiAux);
   G__get_linked_tagnum_fwd(&G__PamVMC_fcCintLN_TVirtualMCApplication);
   G__get_linked_tagnum_fwd(&G__PamVMC_fcCintLN_TVirtualMCStack);
   G__get_linked_tagnum_fwd(&G__PamVMC_fcCintLN_TMCVerbose);
   G__get_linked_tagnum_fwd(&G__PamVMC_fcCintLN_TMCProcess);
   G__get_linked_tagnum_fwd(&G__PamVMC_fcCintLN_TVirtualMC);
   G__get_linked_tagnum_fwd(&G__PamVMC_fcCintLN_TAtt3D);
   G__get_linked_tagnum_fwd(&G__PamVMC_fcCintLN_PamVMCGeoID);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__PamVMC_fcCintLN_pHitData),sizeof(pHitData),-1,291072,(char*)NULL,G__setup_memvarpHitData,G__setup_memfuncpHitData);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__PamVMC_fcCintLN_PamVMCDetectorHit),sizeof(PamVMCDetectorHit),-1,294144,"PamVMCDetectorHit  ",G__setup_memvarPamVMCDetectorHit,G__setup_memfuncPamVMCDetectorHit);
   G__get_linked_tagnum_fwd(&G__PamVMC_fcCintLN_vectorlETStringcOallocatorlETStringgRsPgR);
   G__get_linked_tagnum_fwd(&G__PamVMC_fcCintLN_reverse_iteratorlEvectorlETStringcOallocatorlETStringgRsPgRcLcLiteratorgR);
   G__get_linked_tagnum_fwd(&G__PamVMC_fcCintLN_TRandom3);
   G__get_linked_tagnum_fwd(&G__PamVMC_fcCintLN_pairlEunsignedsPintcOintgR);
   G__get_linked_tagnum_fwd(&G__PamVMC_fcCintLN_vectorlEpairlEunsignedsPintcOintgRcOallocatorlEpairlEunsignedsPintcOintgRsPgRsPgR);
   G__get_linked_tagnum_fwd(&G__PamVMC_fcCintLN_reverse_iteratorlEvectorlEpairlEunsignedsPintcOintgRcOallocatorlEpairlEunsignedsPintcOintgRsPgRsPgRcLcLiteratorgR);
   G__get_linked_tagnum_fwd(&G__PamVMC_fcCintLN_TF1);
   G__get_linked_tagnum_fwd(&G__PamVMC_fcCintLN_maplEintcOdoublecOlesslEintgRcOallocatorlEpairlEconstsPintcOdoublegRsPgRsPgR);
   G__get_linked_tagnum_fwd(&G__PamVMC_fcCintLN_PamVMCSQLMgr);
   G__get_linked_tagnum_fwd(&G__PamVMC_fcCintLN_PamVMCRawMgr);
   G__get_linked_tagnum_fwd(&G__PamVMC_fcCintLN_TXMLNode);
   G__get_linked_tagnum_fwd(&G__PamVMC_fcCintLN_pInitModeOpt);
   G__get_linked_tagnum_fwd(&G__PamVMC_fcCintLN_pRandomModeOpt);
   G__get_linked_tagnum_fwd(&G__PamVMC_fcCintLN_Save_cond);
   G__get_linked_tagnum_fwd(&G__PamVMC_fcCintLN_Save_mode);
   G__get_linked_tagnum_fwd(&G__PamVMC_fcCintLN_pRuntimeModeOpt);
   G__get_linked_tagnum_fwd(&G__PamVMC_fcCintLN_Momentum_mode);
   G__get_linked_tagnum_fwd(&G__PamVMC_fcCintLN_Momentum_units);
   G__get_linked_tagnum_fwd(&G__PamVMC_fcCintLN_Nevents_mode);
   G__get_linked_tagnum_fwd(&G__PamVMC_fcCintLN_pPrimaryModeOpt);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__PamVMC_fcCintLN_PamVMCOptMgr),sizeof(PamVMCOptMgr),-1,292096,(char*)NULL,G__setup_memvarPamVMCOptMgr,G__setup_memfuncPamVMCOptMgr);
   G__get_linked_tagnum_fwd(&G__PamVMC_fcCintLN_PamVMCRndMgr);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__PamVMC_fcCintLN_PamVMCDigitizer),sizeof(PamVMCDigitizer),-1,292097,(char*)NULL,G__setup_memvarPamVMCDigitizer,G__setup_memfuncPamVMCDigitizer);
   G__get_linked_tagnum_fwd(&G__PamVMC_fcCintLN_cGPSSPE);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__PamVMC_fcCintLN_GPSSPEData),sizeof(GPSSPEData),-1,292096,(char*)NULL,G__setup_memvarGPSSPEData,G__setup_memfuncGPSSPEData);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__PamVMC_fcCintLN_pGPSSPEHits),sizeof(pGPSSPEHits),-1,263424,(char*)NULL,G__setup_memvarpGPSSPEHits,G__setup_memfuncpGPSSPEHits);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__PamVMC_fcCintLN_PamVMCTrkDig),sizeof(PamVMCTrkDig),-1,292096,(char*)NULL,G__setup_memvarPamVMCTrkDig,G__setup_memfuncPamVMCTrkDig);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__PamVMC_fcCintLN_PamVMCTofDig),sizeof(PamVMCTofDig),-1,292096,(char*)NULL,G__setup_memvarPamVMCTofDig,G__setup_memfuncPamVMCTofDig);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__PamVMC_fcCintLN_PamVMCAcDig),sizeof(PamVMCAcDig),-1,292096,(char*)NULL,G__setup_memvarPamVMCAcDig,G__setup_memfuncPamVMCAcDig);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__PamVMC_fcCintLN_PamVMCCaloDig),sizeof(PamVMCCaloDig),-1,292096,(char*)NULL,G__setup_memvarPamVMCCaloDig,G__setup_memfuncPamVMCCaloDig);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__PamVMC_fcCintLN_PamVMCS4Dig),sizeof(PamVMCS4Dig),-1,292096,(char*)NULL,G__setup_memvarPamVMCS4Dig,G__setup_memfuncPamVMCS4Dig);
   G__get_linked_tagnum_fwd(&G__PamVMC_fcCintLN_vectorlEPamVMCDetectorHitmUcOallocatorlEPamVMCDetectorHitmUgRsPgR);
   G__get_linked_tagnum_fwd(&G__PamVMC_fcCintLN_reverse_iteratorlEvectorlEPamVMCDetectorHitmUcOallocatorlEPamVMCDetectorHitmUgRsPgRcLcLiteratorgR);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__PamVMC_fcCintLN_PamVMCNDDig),sizeof(PamVMCNDDig),-1,292096,(char*)NULL,G__setup_memvarPamVMCNDDig,G__setup_memfuncPamVMCNDDig);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__PamVMC_fcCintLN_PamVMCParticle),sizeof(PamVMCParticle),-1,324864,(char*)NULL,G__setup_memvarPamVMCParticle,G__setup_memfuncPamVMCParticle);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__PamVMC_fcCintLN_PamVMCStack),sizeof(PamVMCStack),-1,324864,"PamVMCStack",G__setup_memvarPamVMCStack,G__setup_memfuncPamVMCStack);
   G__get_linked_tagnum_fwd(&G__PamVMC_fcCintLN_dequelEPamVMCParticlemUcOallocatorlEPamVMCParticlemUgRsPgR);
   G__get_linked_tagnum_fwd(&G__PamVMC_fcCintLN_stacklEPamVMCParticlemUcOdequelEPamVMCParticlemUcOallocatorlEPamVMCParticlemUgRsPgRsPgR);
   G__get_linked_tagnum_fwd(&G__PamVMC_fcCintLN_fin);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__PamVMC_fcCintLN_PamVMCDetectorSD),sizeof(PamVMCDetectorSD),-1,292096,(char*)NULL,G__setup_memvarPamVMCDetectorSD,G__setup_memfuncPamVMCDetectorSD);
   G__get_linked_tagnum_fwd(&G__PamVMC_fcCintLN_maplEconstsPpamelacLcLPacketTypemUcOTTreemUcOlesslEconstsPpamelacLcLPacketTypemUgRcOallocatorlEpairlEconstsPpamelacLcLPacketTypemUsPconstcOTTreemUgRsPgRsPgR);
   G__get_linked_tagnum_fwd(&G__PamVMC_fcCintLN_listlETFilemUcOallocatorlETFilemUgRsPgR);
   G__get_linked_tagnum_fwd(&G__PamVMC_fcCintLN_listlETTreemUcOallocatorlETTreemUgRsPgR);
   G__get_linked_tagnum_fwd(&G__PamVMC_fcCintLN_maplEconstsPpamelacLcLPacketTypemUcOlistlETTreemUcOallocatorlETTreemUgRsPgRcOlesslEconstsPpamelacLcLPacketTypemUgRcOallocatorlEpairlEconstsPpamelacLcLPacketTypemUsPconstcOlistlETTreemUcOallocatorlETTreemUgRsPgRsPgRsPgRsPgR);
   G__get_linked_tagnum_fwd(&G__PamVMC_fcCintLN_maplEstringcOpamelacLcLSubPacketmUcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOpamelacLcLSubPacketmUgRsPgRsPgR);
   G__get_linked_tagnum_fwd(&G__PamVMC_fcCintLN_TMatrixTlEdoublegR);
   G__get_linked_tagnum_fwd(&G__PamVMC_fcCintLN_TMatrixTRow_constlEdoublegR);
   G__get_linked_tagnum_fwd(&G__PamVMC_fcCintLN_TMatrixTRowlEdoublegR);
   G__get_linked_tagnum_fwd(&G__PamVMC_fcCintLN_TMatrixTDiag_constlEdoublegR);
   G__get_linked_tagnum_fwd(&G__PamVMC_fcCintLN_TMatrixTColumn_constlEdoublegR);
   G__get_linked_tagnum_fwd(&G__PamVMC_fcCintLN_TMatrixTFlat_constlEdoublegR);
   G__get_linked_tagnum_fwd(&G__PamVMC_fcCintLN_TMatrixTSub_constlEdoublegR);
   G__get_linked_tagnum_fwd(&G__PamVMC_fcCintLN_TMatrixTSparseRow_constlEdoublegR);
   G__get_linked_tagnum_fwd(&G__PamVMC_fcCintLN_TMatrixTSparseDiag_constlEdoublegR);
   G__get_linked_tagnum_fwd(&G__PamVMC_fcCintLN_TMatrixTColumnlEdoublegR);
   G__get_linked_tagnum_fwd(&G__PamVMC_fcCintLN_TMatrixTDiaglEdoublegR);
   G__get_linked_tagnum_fwd(&G__PamVMC_fcCintLN_TMatrixTFlatlEdoublegR);
   G__get_linked_tagnum_fwd(&G__PamVMC_fcCintLN_TMatrixTSublEdoublegR);
   G__get_linked_tagnum_fwd(&G__PamVMC_fcCintLN_TMatrixTSparseRowlEdoublegR);
   G__get_linked_tagnum_fwd(&G__PamVMC_fcCintLN_TMatrixTSparseDiaglEdoublegR);
   G__get_linked_tagnum_fwd(&G__PamVMC_fcCintLN_vectorlEPamVMCPlCrossmUcOallocatorlEPamVMCPlCrossmUgRsPgR);
   G__get_linked_tagnum_fwd(&G__PamVMC_fcCintLN_reverse_iteratorlEvectorlEPamVMCPlCrossmUcOallocatorlEPamVMCPlCrossmUgRsPgRcLcLiteratorgR);
   G__get_linked_tagnum_fwd(&G__PamVMC_fcCintLN_PamVMCPrimaryGF);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__PamVMC_fcCintLN_PamVMCPrimary),sizeof(PamVMCPrimary),-1,292096,(char*)NULL,G__setup_memvarPamVMCPrimary,G__setup_memfuncPamVMCPrimary);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__PamVMC_fcCintLN_PamVMCPrimaryGenerator),sizeof(PamVMCPrimaryGenerator),-1,324864,"PamVMCPrimaryGenerator",G__setup_memvarPamVMCPrimaryGenerator,G__setup_memfuncPamVMCPrimaryGenerator);
   G__get_linked_tagnum_fwd(&G__PamVMC_fcCintLN_maplEintcOTGeoElementRNmUcOlesslEintgRcOallocatorlEpairlEconstsPintcOTGeoElementRNmUgRsPgRsPgR);
   G__get_linked_tagnum_fwd(&G__PamVMC_fcCintLN_TGeoMaterial);
   G__get_linked_tagnum_fwd(&G__PamVMC_fcCintLN_TGeoMedium);
   G__get_linked_tagnum_fwd(&G__PamVMC_fcCintLN_TGeoMatrix);
   G__get_linked_tagnum_fwd(&G__PamVMC_fcCintLN_TGeoVolume);
   G__get_linked_tagnum_fwd(&G__PamVMC_fcCintLN_vectorlETGeoVolumeAssemblycLcLThreadData_tmUcOallocatorlETGeoVolumeAssemblycLcLThreadData_tmUgRsPgR);
   G__get_linked_tagnum_fwd(&G__PamVMC_fcCintLN_reverse_iteratorlEvectorlETGeoVolumeAssemblycLcLThreadData_tmUcOallocatorlETGeoVolumeAssemblycLcLThreadData_tmUgRsPgRcLcLiteratorgR);
   G__get_linked_tagnum_fwd(&G__PamVMC_fcCintLN_TGeoRotation);
   G__get_linked_tagnum_fwd(&G__PamVMC_fcCintLN_maplElongcOTGeoNavigatorArraymUcOlesslElonggRcOallocatorlEpairlEconstsPlongcOTGeoNavigatorArraymUgRsPgRsPgR);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__PamVMC_fcCintLN_pCutControl),sizeof(pCutControl),-1,324864,(char*)NULL,G__setup_memvarpCutControl,G__setup_memfuncpCutControl);
   G__get_linked_tagnum_fwd(&G__PamVMC_fcCintLN_pMotherProp);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__PamVMC_fcCintLN_PamVMCDetGeom),sizeof(PamVMCDetGeom),-1,292096,(char*)NULL,G__setup_memvarPamVMCDetGeom,G__setup_memfuncPamVMCDetGeom);
   G__get_linked_tagnum_fwd(&G__PamVMC_fcCintLN_PamVMCDetGeomcLcLkind);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__PamVMC_fcCintLN_PamVMCDetector),sizeof(PamVMCDetector),-1,292098,(char*)NULL,G__setup_memvarPamVMCDetector,G__setup_memfuncPamVMCDetector);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__PamVMC_fcCintLN_PamVMCCaloSD),sizeof(PamVMCCaloSD),-1,291072,(char*)NULL,G__setup_memvarPamVMCCaloSD,G__setup_memfuncPamVMCCaloSD);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__PamVMC_fcCintLN_PamVMCDetCalo),sizeof(PamVMCDetCalo),-1,291072,(char*)NULL,G__setup_memvarPamVMCDetCalo,G__setup_memfuncPamVMCDetCalo);
   G__get_linked_tagnum_fwd(&G__PamVMC_fcCintLN_maplEintcOpCombTransmUcOlesslEintgRcOallocatorlEpairlEconstsPintcOpCombTransmUgRsPgRsPgR);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__PamVMC_fcCintLN_pTrkHitData),sizeof(pTrkHitData),-1,292096,(char*)NULL,G__setup_memvarpTrkHitData,G__setup_memfuncpTrkHitData);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__PamVMC_fcCintLN_PamVMCTrkHit),sizeof(PamVMCTrkHit),-1,294144,"PamVMCTrkHit  ",G__setup_memvarPamVMCTrkHit,G__setup_memfuncPamVMCTrkHit);
   G__get_linked_tagnum_fwd(&G__PamVMC_fcCintLN_cGPCSPE);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__PamVMC_fcCintLN_PamVMCTrkSD),sizeof(PamVMCTrkSD),-1,292096,(char*)NULL,G__setup_memvarPamVMCTrkSD,G__setup_memfuncPamVMCTrkSD);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__PamVMC_fcCintLN_PamVMCDetTrk),sizeof(PamVMCDetTrk),-1,292096,(char*)NULL,G__setup_memvarPamVMCDetTrk,G__setup_memfuncPamVMCDetTrk);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__PamVMC_fcCintLN_PamVMCTofSD),sizeof(PamVMCTofSD),-1,323584,(char*)NULL,G__setup_memvarPamVMCTofSD,G__setup_memfuncPamVMCTofSD);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__PamVMC_fcCintLN_PamVMCDetTofS1),sizeof(PamVMCDetTofS1),-1,291072,(char*)NULL,G__setup_memvarPamVMCDetTofS1,G__setup_memfuncPamVMCDetTofS1);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__PamVMC_fcCintLN_PamVMCDetTofS2),sizeof(PamVMCDetTofS2),-1,291072,(char*)NULL,G__setup_memvarPamVMCDetTofS2,G__setup_memfuncPamVMCDetTofS2);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__PamVMC_fcCintLN_PamVMCDetTofS3),sizeof(PamVMCDetTofS3),-1,291072,(char*)NULL,G__setup_memvarPamVMCDetTofS3,G__setup_memfuncPamVMCDetTofS3);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__PamVMC_fcCintLN_PamVMCDetTof),sizeof(PamVMCDetTof),-1,291072,(char*)NULL,G__setup_memvarPamVMCDetTof,G__setup_memfuncPamVMCDetTof);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__PamVMC_fcCintLN_PamVMCCardSD),sizeof(PamVMCCardSD),-1,323584,(char*)NULL,G__setup_memvarPamVMCCardSD,G__setup_memfuncPamVMCCardSD);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__PamVMC_fcCintLN_PamVMCDetCard),sizeof(PamVMCDetCard),-1,291072,(char*)NULL,G__setup_memvarPamVMCDetCard,G__setup_memfuncPamVMCDetCard);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__PamVMC_fcCintLN_PamVMCCasSD),sizeof(PamVMCCasSD),-1,291072,(char*)NULL,G__setup_memvarPamVMCCasSD,G__setup_memfuncPamVMCCasSD);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__PamVMC_fcCintLN_PamVMCDetCas),sizeof(PamVMCDetCas),-1,291072,(char*)NULL,G__setup_memvarPamVMCDetCas,G__setup_memfuncPamVMCDetCas);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__PamVMC_fcCintLN_PamVMCCatSD),sizeof(PamVMCCatSD),-1,291072,(char*)NULL,G__setup_memvarPamVMCCatSD,G__setup_memfuncPamVMCCatSD);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__PamVMC_fcCintLN_PamVMCDetCat),sizeof(PamVMCDetCat),-1,291072,(char*)NULL,G__setup_memvarPamVMCDetCat,G__setup_memfuncPamVMCDetCat);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__PamVMC_fcCintLN_PamVMCDetAc),sizeof(PamVMCDetAc),-1,291072,(char*)NULL,G__setup_memvarPamVMCDetAc,G__setup_memfuncPamVMCDetAc);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__PamVMC_fcCintLN_PamVMCS4SD),sizeof(PamVMCS4SD),-1,291072,(char*)NULL,G__setup_memvarPamVMCS4SD,G__setup_memfuncPamVMCS4SD);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__PamVMC_fcCintLN_PamVMCDetS4),sizeof(PamVMCDetS4),-1,291072,(char*)NULL,G__setup_memvarPamVMCDetS4,G__setup_memfuncPamVMCDetS4);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__PamVMC_fcCintLN_PamVMCNDSD),sizeof(PamVMCNDSD),-1,291072,(char*)NULL,G__setup_memvarPamVMCNDSD,G__setup_memfuncPamVMCNDSD);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__PamVMC_fcCintLN_PamVMCDetND),sizeof(PamVMCDetND),-1,291072,(char*)NULL,G__setup_memvarPamVMCDetND,G__setup_memfuncPamVMCDetND);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__PamVMC_fcCintLN_PamVMCDetPamela),sizeof(PamVMCDetPamela),-1,291072,(char*)NULL,G__setup_memvarPamVMCDetPamela,G__setup_memfuncPamVMCDetPamela);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__PamVMC_fcCintLN_PamVMCApplication),sizeof(PamVMCApplication),-1,324608,"Interface to MonteCarlo application",G__setup_memvarPamVMCApplication,G__setup_memfuncPamVMCApplication);
}
extern "C" void G__cpp_setupPamVMC_fcCint(void) {
  G__check_setup_version(30051515,"G__cpp_setupPamVMC_fcCint()");
  G__set_cpp_environmentPamVMC_fcCint();
  G__cpp_setup_tagtablePamVMC_fcCint();

  G__cpp_setup_inheritancePamVMC_fcCint();

  G__cpp_setup_typetablePamVMC_fcCint();

  G__cpp_setup_memvarPamVMC_fcCint();

  G__cpp_setup_memfuncPamVMC_fcCint();
  G__cpp_setup_globalPamVMC_fcCint();
  G__cpp_setup_funcPamVMC_fcCint();

   if(0==G__getsizep2memfunc()) G__get_sizep2memfuncPamVMC_fcCint();
  return;
}
class G__cpp_setup_initPamVMC_fcCint {
  public:
    G__cpp_setup_initPamVMC_fcCint() { G__add_setup_func("PamVMC_fcCint",(G__incsetup)(&G__cpp_setupPamVMC_fcCint)); G__call_setup_funcs(); }
   ~G__cpp_setup_initPamVMC_fcCint() { G__remove_setup_func("PamVMC_fcCint"); }
};
G__cpp_setup_initPamVMC_fcCint G__cpp_setup_initializerPamVMC_fcCint;