GaudiPythonDict.cpp

Go to the documentation of this file.

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

#define R__DICTIONARY_FILENAME GaudiPythonDict

/*******************************************************************/
#include <stddef.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
#define G__DICTIONARY
#include "RConfig.h"
#include "TClass.h"
#include "TDictAttributeMap.h"
#include "TInterpreter.h"
#include "TROOT.h"
#include "TBuffer.h"
#include "TMemberInspector.h"
#include "TInterpreter.h"
#include "TVirtualMutex.h"
#include "TError.h"

#ifndef G__ROOT
#define G__ROOT
#endif

#include "RtypesImp.h"
#include "TIsAProxy.h"
#include "TFileMergeInfo.h"
#include <algorithm>
#include "TCollectionProxyInfo.h"
/*******************************************************************/

#include "TDataMember.h"

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

// Header files passed as explicit arguments
#include "/builds/gaudi/Gaudi/GaudiPython/dict/kernel.h"

// Header files passed via #pragma extra_include

namespace ROOT {
   static TClass *allocatorlEIServicemUgR_Dictionary();
   static void allocatorlEIServicemUgR_TClassManip(TClass*);
   static void *new_allocatorlEIServicemUgR(void *p = 0);
   static void *newArray_allocatorlEIServicemUgR(Long_t size, void *p);
   static void delete_allocatorlEIServicemUgR(void *p);
   static void deleteArray_allocatorlEIServicemUgR(void *p);
   static void destruct_allocatorlEIServicemUgR(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const allocator<IService*>*)
   {
      allocator<IService*> *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(allocator<IService*>));
      static ::ROOT::TGenericClassInfo 
         instance("allocator<IService*>", "string", 97,
                  typeid(allocator<IService*>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &allocatorlEIServicemUgR_Dictionary, isa_proxy, 4,
                  sizeof(allocator<IService*>) );
      instance.SetNew(&new_allocatorlEIServicemUgR);
      instance.SetNewArray(&newArray_allocatorlEIServicemUgR);
      instance.SetDelete(&delete_allocatorlEIServicemUgR);
      instance.SetDeleteArray(&deleteArray_allocatorlEIServicemUgR);
      instance.SetDestructor(&destruct_allocatorlEIServicemUgR);
      return &instance;
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const allocator<IService*>*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *allocatorlEIServicemUgR_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal((const allocator<IService*>*)0x0)->GetClass();
      allocatorlEIServicemUgR_TClassManip(theClass);
   return theClass;
   }

   static void allocatorlEIServicemUgR_TClassManip(TClass* ){
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *allocatorlEIAlgorithmmUgR_Dictionary();
   static void allocatorlEIAlgorithmmUgR_TClassManip(TClass*);
   static void *new_allocatorlEIAlgorithmmUgR(void *p = 0);
   static void *newArray_allocatorlEIAlgorithmmUgR(Long_t size, void *p);
   static void delete_allocatorlEIAlgorithmmUgR(void *p);
   static void deleteArray_allocatorlEIAlgorithmmUgR(void *p);
   static void destruct_allocatorlEIAlgorithmmUgR(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const allocator<IAlgorithm*>*)
   {
      allocator<IAlgorithm*> *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(allocator<IAlgorithm*>));
      static ::ROOT::TGenericClassInfo 
         instance("allocator<IAlgorithm*>", "string", 97,
                  typeid(allocator<IAlgorithm*>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &allocatorlEIAlgorithmmUgR_Dictionary, isa_proxy, 4,
                  sizeof(allocator<IAlgorithm*>) );
      instance.SetNew(&new_allocatorlEIAlgorithmmUgR);
      instance.SetNewArray(&newArray_allocatorlEIAlgorithmmUgR);
      instance.SetDelete(&delete_allocatorlEIAlgorithmmUgR);
      instance.SetDeleteArray(&deleteArray_allocatorlEIAlgorithmmUgR);
      instance.SetDestructor(&destruct_allocatorlEIAlgorithmmUgR);
      return &instance;
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const allocator<IAlgorithm*>*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *allocatorlEIAlgorithmmUgR_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal((const allocator<IAlgorithm*>*)0x0)->GetClass();
      allocatorlEIAlgorithmmUgR_TClassManip(theClass);
   return theClass;
   }

   static void allocatorlEIAlgorithmmUgR_TClassManip(TClass* ){
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *allocatorlEIRegistrymUgR_Dictionary();
   static void allocatorlEIRegistrymUgR_TClassManip(TClass*);
   static void *new_allocatorlEIRegistrymUgR(void *p = 0);
   static void *newArray_allocatorlEIRegistrymUgR(Long_t size, void *p);
   static void delete_allocatorlEIRegistrymUgR(void *p);
   static void deleteArray_allocatorlEIRegistrymUgR(void *p);
   static void destruct_allocatorlEIRegistrymUgR(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const allocator<IRegistry*>*)
   {
      allocator<IRegistry*> *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(allocator<IRegistry*>));
      static ::ROOT::TGenericClassInfo 
         instance("allocator<IRegistry*>", "string", 97,
                  typeid(allocator<IRegistry*>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &allocatorlEIRegistrymUgR_Dictionary, isa_proxy, 4,
                  sizeof(allocator<IRegistry*>) );
      instance.SetNew(&new_allocatorlEIRegistrymUgR);
      instance.SetNewArray(&newArray_allocatorlEIRegistrymUgR);
      instance.SetDelete(&delete_allocatorlEIRegistrymUgR);
      instance.SetDeleteArray(&deleteArray_allocatorlEIRegistrymUgR);
      instance.SetDestructor(&destruct_allocatorlEIRegistrymUgR);
      return &instance;
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const allocator<IRegistry*>*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *allocatorlEIRegistrymUgR_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal((const allocator<IRegistry*>*)0x0)->GetClass();
      allocatorlEIRegistrymUgR_TClassManip(theClass);
   return theClass;
   }

   static void allocatorlEIRegistrymUgR_TClassManip(TClass* ){
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *basic_ostreamlEcharcOchar_traitslEchargRsPgR_Dictionary();
   static void basic_ostreamlEcharcOchar_traitslEchargRsPgR_TClassManip(TClass*);
   static void delete_basic_ostreamlEcharcOchar_traitslEchargRsPgR(void *p);
   static void deleteArray_basic_ostreamlEcharcOchar_traitslEchargRsPgR(void *p);
   static void destruct_basic_ostreamlEcharcOchar_traitslEchargRsPgR(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::basic_ostream<char,char_traits<char> >*)
   {
      ::basic_ostream<char,char_traits<char> > *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::basic_ostream<char,char_traits<char> >));
      static ::ROOT::TGenericClassInfo 
         instance("basic_ostream<char,char_traits<char> >", "ostream", 359,
                  typeid(::basic_ostream<char,char_traits<char> >), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &basic_ostreamlEcharcOchar_traitslEchargRsPgR_Dictionary, isa_proxy, 4,
                  sizeof(::basic_ostream<char,char_traits<char> >) );
      instance.SetDelete(&delete_basic_ostreamlEcharcOchar_traitslEchargRsPgR);
      instance.SetDeleteArray(&deleteArray_basic_ostreamlEcharcOchar_traitslEchargRsPgR);
      instance.SetDestructor(&destruct_basic_ostreamlEcharcOchar_traitslEchargRsPgR);

      ::ROOT::AddClassAlternate("basic_ostream<char,char_traits<char> >","ostream");
      return &instance;
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::basic_ostream<char,char_traits<char> >*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *basic_ostreamlEcharcOchar_traitslEchargRsPgR_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::basic_ostream<char,char_traits<char> >*)0x0)->GetClass();
      basic_ostreamlEcharcOchar_traitslEchargRsPgR_TClassManip(theClass);
   return theClass;
   }

   static void basic_ostreamlEcharcOchar_traitslEchargRsPgR_TClassManip(TClass* ){
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *_Bit_reference_Dictionary();
   static void _Bit_reference_TClassManip(TClass*);
   static void *new__Bit_reference(void *p = 0);
   static void *newArray__Bit_reference(Long_t size, void *p);
   static void delete__Bit_reference(void *p);
   static void deleteArray__Bit_reference(void *p);
   static void destruct__Bit_reference(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::_Bit_reference*)
   {
      ::_Bit_reference *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::_Bit_reference));
      static ::ROOT::TGenericClassInfo 
         instance("_Bit_reference", "vector", 70,
                  typeid(::_Bit_reference), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &_Bit_reference_Dictionary, isa_proxy, 4,
                  sizeof(::_Bit_reference) );
      instance.SetNew(&new__Bit_reference);
      instance.SetNewArray(&newArray__Bit_reference);
      instance.SetDelete(&delete__Bit_reference);
      instance.SetDeleteArray(&deleteArray__Bit_reference);
      instance.SetDestructor(&destruct__Bit_reference);
      return &instance;
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::_Bit_reference*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *_Bit_reference_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::_Bit_reference*)0x0)->GetClass();
      _Bit_reference_TClassManip(theClass);
   return theClass;
   }

   static void _Bit_reference_TClassManip(TClass* ){
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *basic_stringbuflEcharcOchar_traitslEchargRcOallocatorlEchargRsPgR_Dictionary();
   static void basic_stringbuflEcharcOchar_traitslEchargRcOallocatorlEchargRsPgR_TClassManip(TClass*);
   static void *new_basic_stringbuflEcharcOchar_traitslEchargRcOallocatorlEchargRsPgR(void *p = 0);
   static void *newArray_basic_stringbuflEcharcOchar_traitslEchargRcOallocatorlEchargRsPgR(Long_t size, void *p);
   static void delete_basic_stringbuflEcharcOchar_traitslEchargRcOallocatorlEchargRsPgR(void *p);
   static void deleteArray_basic_stringbuflEcharcOchar_traitslEchargRcOallocatorlEchargRsPgR(void *p);
   static void destruct_basic_stringbuflEcharcOchar_traitslEchargRcOallocatorlEchargRsPgR(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::basic_stringbuf<char,char_traits<char>,allocator<char> >*)
   {
      ::basic_stringbuf<char,char_traits<char>,allocator<char> > *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::basic_stringbuf<char,char_traits<char>,allocator<char> >));
      static ::ROOT::TGenericClassInfo 
         instance("basic_stringbuf<char,char_traits<char>,allocator<char> >", "sstream", 272,
                  typeid(::basic_stringbuf<char,char_traits<char>,allocator<char> >), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &basic_stringbuflEcharcOchar_traitslEchargRcOallocatorlEchargRsPgR_Dictionary, isa_proxy, 4,
                  sizeof(::basic_stringbuf<char,char_traits<char>,allocator<char> >) );
      instance.SetNew(&new_basic_stringbuflEcharcOchar_traitslEchargRcOallocatorlEchargRsPgR);
      instance.SetNewArray(&newArray_basic_stringbuflEcharcOchar_traitslEchargRcOallocatorlEchargRsPgR);
      instance.SetDelete(&delete_basic_stringbuflEcharcOchar_traitslEchargRcOallocatorlEchargRsPgR);
      instance.SetDeleteArray(&deleteArray_basic_stringbuflEcharcOchar_traitslEchargRcOallocatorlEchargRsPgR);
      instance.SetDestructor(&destruct_basic_stringbuflEcharcOchar_traitslEchargRcOallocatorlEchargRsPgR);

      ::ROOT::AddClassAlternate("basic_stringbuf<char,char_traits<char>,allocator<char> >","basic_stringbuf<char,std::char_traits<char>,std::allocator<char> >");
      return &instance;
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::basic_stringbuf<char,char_traits<char>,allocator<char> >*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *basic_stringbuflEcharcOchar_traitslEchargRcOallocatorlEchargRsPgR_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::basic_stringbuf<char,char_traits<char>,allocator<char> >*)0x0)->GetClass();
      basic_stringbuflEcharcOchar_traitslEchargRcOallocatorlEchargRsPgR_TClassManip(theClass);
   return theClass;
   }

   static void basic_stringbuflEcharcOchar_traitslEchargRcOallocatorlEchargRsPgR_TClassManip(TClass* ){
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *GaudicLcLUtilscLcLMapBase_Dictionary();
   static void GaudicLcLUtilscLcLMapBase_TClassManip(TClass*);
   static void *new_GaudicLcLUtilscLcLMapBase(void *p = 0);
   static void *newArray_GaudicLcLUtilscLcLMapBase(Long_t size, void *p);
   static void delete_GaudicLcLUtilscLcLMapBase(void *p);
   static void deleteArray_GaudicLcLUtilscLcLMapBase(void *p);
   static void destruct_GaudicLcLUtilscLcLMapBase(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::Gaudi::Utils::MapBase*)
   {
      ::Gaudi::Utils::MapBase *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::Gaudi::Utils::MapBase));
      static ::ROOT::TGenericClassInfo 
         instance("Gaudi::Utils::MapBase", "GaudiKernel/MapBase.h", 44,
                  typeid(::Gaudi::Utils::MapBase), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &GaudicLcLUtilscLcLMapBase_Dictionary, isa_proxy, 4,
                  sizeof(::Gaudi::Utils::MapBase) );
      instance.SetNew(&new_GaudicLcLUtilscLcLMapBase);
      instance.SetNewArray(&newArray_GaudicLcLUtilscLcLMapBase);
      instance.SetDelete(&delete_GaudicLcLUtilscLcLMapBase);
      instance.SetDeleteArray(&deleteArray_GaudicLcLUtilscLcLMapBase);
      instance.SetDestructor(&destruct_GaudicLcLUtilscLcLMapBase);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::Gaudi::Utils::MapBase*)
   {
      return GenerateInitInstanceLocal((::Gaudi::Utils::MapBase*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::Gaudi::Utils::MapBase*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *GaudicLcLUtilscLcLMapBase_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::Gaudi::Utils::MapBase*)0x0)->GetClass();
      GaudicLcLUtilscLcLMapBase_TClassManip(theClass);
   return theClass;
   }

   static void GaudicLcLUtilscLcLMapBase_TClassManip(TClass* ){
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *GaudicLcLStringKey_Dictionary();
   static void GaudicLcLStringKey_TClassManip(TClass*);
   static void *new_GaudicLcLStringKey(void *p = 0);
   static void *newArray_GaudicLcLStringKey(Long_t size, void *p);
   static void delete_GaudicLcLStringKey(void *p);
   static void deleteArray_GaudicLcLStringKey(void *p);
   static void destruct_GaudicLcLStringKey(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::Gaudi::StringKey*)
   {
      ::Gaudi::StringKey *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::Gaudi::StringKey));
      static ::ROOT::TGenericClassInfo 
         instance("Gaudi::StringKey", "GaudiKernel/StringKey.h", 35,
                  typeid(::Gaudi::StringKey), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &GaudicLcLStringKey_Dictionary, isa_proxy, 4,
                  sizeof(::Gaudi::StringKey) );
      instance.SetNew(&new_GaudicLcLStringKey);
      instance.SetNewArray(&newArray_GaudicLcLStringKey);
      instance.SetDelete(&delete_GaudicLcLStringKey);
      instance.SetDeleteArray(&deleteArray_GaudicLcLStringKey);
      instance.SetDestructor(&destruct_GaudicLcLStringKey);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::Gaudi::StringKey*)
   {
      return GenerateInitInstanceLocal((::Gaudi::StringKey*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::Gaudi::StringKey*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *GaudicLcLStringKey_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::Gaudi::StringKey*)0x0)->GetClass();
      GaudicLcLStringKey_TClassManip(theClass);
   return theClass;
   }

   static void GaudicLcLStringKey_TClassManip(TClass* ){
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *StatEntity_Dictionary();
   static void StatEntity_TClassManip(TClass*);
   static void *new_StatEntity(void *p = 0);
   static void *newArray_StatEntity(Long_t size, void *p);
   static void delete_StatEntity(void *p);
   static void deleteArray_StatEntity(void *p);
   static void destruct_StatEntity(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::StatEntity*)
   {
      ::StatEntity *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::StatEntity));
      static ::ROOT::TGenericClassInfo 
         instance("StatEntity", "GaudiKernel/Counters.h", 777,
                  typeid(::StatEntity), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &StatEntity_Dictionary, isa_proxy, 4,
                  sizeof(::StatEntity) );
      instance.SetNew(&new_StatEntity);
      instance.SetNewArray(&newArray_StatEntity);
      instance.SetDelete(&delete_StatEntity);
      instance.SetDeleteArray(&deleteArray_StatEntity);
      instance.SetDestructor(&destruct_StatEntity);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::StatEntity*)
   {
      return GenerateInitInstanceLocal((::StatEntity*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::StatEntity*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *StatEntity_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::StatEntity*)0x0)->GetClass();
      StatEntity_TClassManip(theClass);
   return theClass;
   }

   static void StatEntity_TClassManip(TClass* ){
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *ChronoEntity_Dictionary();
   static void ChronoEntity_TClassManip(TClass*);
   static void *new_ChronoEntity(void *p = 0);
   static void *newArray_ChronoEntity(Long_t size, void *p);
   static void delete_ChronoEntity(void *p);
   static void deleteArray_ChronoEntity(void *p);
   static void destruct_ChronoEntity(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::ChronoEntity*)
   {
      ::ChronoEntity *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::ChronoEntity));
      static ::ROOT::TGenericClassInfo 
         instance("ChronoEntity", "GaudiKernel/ChronoEntity.h", 21,
                  typeid(::ChronoEntity), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &ChronoEntity_Dictionary, isa_proxy, 4,
                  sizeof(::ChronoEntity) );
      instance.SetNew(&new_ChronoEntity);
      instance.SetNewArray(&newArray_ChronoEntity);
      instance.SetDelete(&delete_ChronoEntity);
      instance.SetDeleteArray(&deleteArray_ChronoEntity);
      instance.SetDestructor(&destruct_ChronoEntity);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::ChronoEntity*)
   {
      return GenerateInitInstanceLocal((::ChronoEntity*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::ChronoEntity*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *ChronoEntity_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::ChronoEntity*)0x0)->GetClass();
      ChronoEntity_TClassManip(theClass);
   return theClass;
   }

   static void ChronoEntity_TClassManip(TClass* ){
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *Chrono_Dictionary();
   static void Chrono_TClassManip(TClass*);
   static void *new_Chrono(void *p = 0);
   static void *newArray_Chrono(Long_t size, void *p);
   static void delete_Chrono(void *p);
   static void deleteArray_Chrono(void *p);
   static void destruct_Chrono(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::Chrono*)
   {
      ::Chrono *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::Chrono));
      static ::ROOT::TGenericClassInfo 
         instance("Chrono", "GaudiKernel/Chrono.h", 25,
                  typeid(::Chrono), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &Chrono_Dictionary, isa_proxy, 4,
                  sizeof(::Chrono) );
      instance.SetNew(&new_Chrono);
      instance.SetNewArray(&newArray_Chrono);
      instance.SetDelete(&delete_Chrono);
      instance.SetDeleteArray(&deleteArray_Chrono);
      instance.SetDestructor(&destruct_Chrono);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::Chrono*)
   {
      return GenerateInitInstanceLocal((::Chrono*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::Chrono*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *Chrono_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::Chrono*)0x0)->GetClass();
      Chrono_TClassManip(theClass);
   return theClass;
   }

   static void Chrono_TClassManip(TClass* ){
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *ParticleProperty_Dictionary();
   static void ParticleProperty_TClassManip(TClass*);
   static void *new_ParticleProperty(void *p = 0);
   static void *newArray_ParticleProperty(Long_t size, void *p);
   static void delete_ParticleProperty(void *p);
   static void deleteArray_ParticleProperty(void *p);
   static void destruct_ParticleProperty(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::ParticleProperty*)
   {
      ::ParticleProperty *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::ParticleProperty));
      static ::ROOT::TGenericClassInfo 
         instance("ParticleProperty", "GaudiKernel/ParticleProperty.h", 18,
                  typeid(::ParticleProperty), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &ParticleProperty_Dictionary, isa_proxy, 4,
                  sizeof(::ParticleProperty) );
      instance.SetNew(&new_ParticleProperty);
      instance.SetNewArray(&newArray_ParticleProperty);
      instance.SetDelete(&delete_ParticleProperty);
      instance.SetDeleteArray(&deleteArray_ParticleProperty);
      instance.SetDestructor(&destruct_ParticleProperty);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::ParticleProperty*)
   {
      return GenerateInitInstanceLocal((::ParticleProperty*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::ParticleProperty*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *ParticleProperty_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::ParticleProperty*)0x0)->GetClass();
      ParticleProperty_TClassManip(theClass);
   return theClass;
   }

   static void ParticleProperty_TClassManip(TClass* ){
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *GaudicLcLRangeBase__Dictionary();
   static void GaudicLcLRangeBase__TClassManip(TClass*);
   static void *new_GaudicLcLRangeBase_(void *p = 0);
   static void *newArray_GaudicLcLRangeBase_(Long_t size, void *p);
   static void delete_GaudicLcLRangeBase_(void *p);
   static void deleteArray_GaudicLcLRangeBase_(void *p);
   static void destruct_GaudicLcLRangeBase_(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::Gaudi::RangeBase_*)
   {
      ::Gaudi::RangeBase_ *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::Gaudi::RangeBase_));
      static ::ROOT::TGenericClassInfo 
         instance("Gaudi::RangeBase_", "GaudiKernel/Range.h", 62,
                  typeid(::Gaudi::RangeBase_), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &GaudicLcLRangeBase__Dictionary, isa_proxy, 4,
                  sizeof(::Gaudi::RangeBase_) );
      instance.SetNew(&new_GaudicLcLRangeBase_);
      instance.SetNewArray(&newArray_GaudicLcLRangeBase_);
      instance.SetDelete(&delete_GaudicLcLRangeBase_);
      instance.SetDeleteArray(&deleteArray_GaudicLcLRangeBase_);
      instance.SetDestructor(&destruct_GaudicLcLRangeBase_);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::Gaudi::RangeBase_*)
   {
      return GenerateInitInstanceLocal((::Gaudi::RangeBase_*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::Gaudi::RangeBase_*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *GaudicLcLRangeBase__Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::Gaudi::RangeBase_*)0x0)->GetClass();
      GaudicLcLRangeBase__TClassManip(theClass);
   return theClass;
   }

   static void GaudicLcLRangeBase__TClassManip(TClass* ){
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *Stat_Dictionary();
   static void Stat_TClassManip(TClass*);
   static void *new_Stat(void *p = 0);
   static void *newArray_Stat(Long_t size, void *p);
   static void delete_Stat(void *p);
   static void deleteArray_Stat(void *p);
   static void destruct_Stat(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::Stat*)
   {
      ::Stat *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::Stat));
      static ::ROOT::TGenericClassInfo 
         instance("Stat", "GaudiKernel/Stat.h", 46,
                  typeid(::Stat), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &Stat_Dictionary, isa_proxy, 4,
                  sizeof(::Stat) );
      instance.SetNew(&new_Stat);
      instance.SetNewArray(&newArray_Stat);
      instance.SetDelete(&delete_Stat);
      instance.SetDeleteArray(&deleteArray_Stat);
      instance.SetDestructor(&destruct_Stat);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::Stat*)
   {
      return GenerateInitInstanceLocal((::Stat*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::Stat*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *Stat_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::Stat*)0x0)->GetClass();
      Stat_TClassManip(theClass);
   return theClass;
   }

   static void Stat_TClassManip(TClass* ){
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *AIDAcLcLIAxis_Dictionary();
   static void AIDAcLcLIAxis_TClassManip(TClass*);
   static void delete_AIDAcLcLIAxis(void *p);
   static void deleteArray_AIDAcLcLIAxis(void *p);
   static void destruct_AIDAcLcLIAxis(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::AIDA::IAxis*)
   {
      ::AIDA::IAxis *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::AIDA::IAxis));
      static ::ROOT::TGenericClassInfo 
         instance("AIDA::IAxis", "AIDA/IAxis.h", 26,
                  typeid(::AIDA::IAxis), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &AIDAcLcLIAxis_Dictionary, isa_proxy, 4,
                  sizeof(::AIDA::IAxis) );
      instance.SetDelete(&delete_AIDAcLcLIAxis);
      instance.SetDeleteArray(&deleteArray_AIDAcLcLIAxis);
      instance.SetDestructor(&destruct_AIDAcLcLIAxis);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::AIDA::IAxis*)
   {
      return GenerateInitInstanceLocal((::AIDA::IAxis*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::AIDA::IAxis*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *AIDAcLcLIAxis_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::AIDA::IAxis*)0x0)->GetClass();
      AIDAcLcLIAxis_TClassManip(theClass);
   return theClass;
   }

   static void AIDAcLcLIAxis_TClassManip(TClass* ){
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *AIDAcLcLIBaseHistogram_Dictionary();
   static void AIDAcLcLIBaseHistogram_TClassManip(TClass*);
   static void delete_AIDAcLcLIBaseHistogram(void *p);
   static void deleteArray_AIDAcLcLIBaseHistogram(void *p);
   static void destruct_AIDAcLcLIBaseHistogram(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::AIDA::IBaseHistogram*)
   {
      ::AIDA::IBaseHistogram *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::AIDA::IBaseHistogram));
      static ::ROOT::TGenericClassInfo 
         instance("AIDA::IBaseHistogram", "AIDA/IBaseHistogram.h", 29,
                  typeid(::AIDA::IBaseHistogram), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &AIDAcLcLIBaseHistogram_Dictionary, isa_proxy, 4,
                  sizeof(::AIDA::IBaseHistogram) );
      instance.SetDelete(&delete_AIDAcLcLIBaseHistogram);
      instance.SetDeleteArray(&deleteArray_AIDAcLcLIBaseHistogram);
      instance.SetDestructor(&destruct_AIDAcLcLIBaseHistogram);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::AIDA::IBaseHistogram*)
   {
      return GenerateInitInstanceLocal((::AIDA::IBaseHistogram*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::AIDA::IBaseHistogram*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *AIDAcLcLIBaseHistogram_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::AIDA::IBaseHistogram*)0x0)->GetClass();
      AIDAcLcLIBaseHistogram_TClassManip(theClass);
   return theClass;
   }

   static void AIDAcLcLIBaseHistogram_TClassManip(TClass* ){
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *AIDAcLcLIHistogram_Dictionary();
   static void AIDAcLcLIHistogram_TClassManip(TClass*);
   static void delete_AIDAcLcLIHistogram(void *p);
   static void deleteArray_AIDAcLcLIHistogram(void *p);
   static void destruct_AIDAcLcLIHistogram(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::AIDA::IHistogram*)
   {
      ::AIDA::IHistogram *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::AIDA::IHistogram));
      static ::ROOT::TGenericClassInfo 
         instance("AIDA::IHistogram", "AIDA/IHistogram.h", 26,
                  typeid(::AIDA::IHistogram), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &AIDAcLcLIHistogram_Dictionary, isa_proxy, 4,
                  sizeof(::AIDA::IHistogram) );
      instance.SetDelete(&delete_AIDAcLcLIHistogram);
      instance.SetDeleteArray(&deleteArray_AIDAcLcLIHistogram);
      instance.SetDestructor(&destruct_AIDAcLcLIHistogram);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::AIDA::IHistogram*)
   {
      return GenerateInitInstanceLocal((::AIDA::IHistogram*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::AIDA::IHistogram*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *AIDAcLcLIHistogram_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::AIDA::IHistogram*)0x0)->GetClass();
      AIDAcLcLIHistogram_TClassManip(theClass);
   return theClass;
   }

   static void AIDAcLcLIHistogram_TClassManip(TClass* ){
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *AIDAcLcLIHistogram1D_Dictionary();
   static void AIDAcLcLIHistogram1D_TClassManip(TClass*);
   static void delete_AIDAcLcLIHistogram1D(void *p);
   static void deleteArray_AIDAcLcLIHistogram1D(void *p);
   static void destruct_AIDAcLcLIHistogram1D(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::AIDA::IHistogram1D*)
   {
      ::AIDA::IHistogram1D *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::AIDA::IHistogram1D));
      static ::ROOT::TGenericClassInfo 
         instance("AIDA::IHistogram1D", "AIDA/IHistogram1D.h", 28,
                  typeid(::AIDA::IHistogram1D), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &AIDAcLcLIHistogram1D_Dictionary, isa_proxy, 4,
                  sizeof(::AIDA::IHistogram1D) );
      instance.SetDelete(&delete_AIDAcLcLIHistogram1D);
      instance.SetDeleteArray(&deleteArray_AIDAcLcLIHistogram1D);
      instance.SetDestructor(&destruct_AIDAcLcLIHistogram1D);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::AIDA::IHistogram1D*)
   {
      return GenerateInitInstanceLocal((::AIDA::IHistogram1D*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::AIDA::IHistogram1D*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *AIDAcLcLIHistogram1D_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::AIDA::IHistogram1D*)0x0)->GetClass();
      AIDAcLcLIHistogram1D_TClassManip(theClass);
   return theClass;
   }

   static void AIDAcLcLIHistogram1D_TClassManip(TClass* ){
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *AIDAcLcLIHistogram2D_Dictionary();
   static void AIDAcLcLIHistogram2D_TClassManip(TClass*);
   static void delete_AIDAcLcLIHistogram2D(void *p);
   static void deleteArray_AIDAcLcLIHistogram2D(void *p);
   static void destruct_AIDAcLcLIHistogram2D(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::AIDA::IHistogram2D*)
   {
      ::AIDA::IHistogram2D *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::AIDA::IHistogram2D));
      static ::ROOT::TGenericClassInfo 
         instance("AIDA::IHistogram2D", "AIDA/IHistogram2D.h", 28,
                  typeid(::AIDA::IHistogram2D), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &AIDAcLcLIHistogram2D_Dictionary, isa_proxy, 4,
                  sizeof(::AIDA::IHistogram2D) );
      instance.SetDelete(&delete_AIDAcLcLIHistogram2D);
      instance.SetDeleteArray(&deleteArray_AIDAcLcLIHistogram2D);
      instance.SetDestructor(&destruct_AIDAcLcLIHistogram2D);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::AIDA::IHistogram2D*)
   {
      return GenerateInitInstanceLocal((::AIDA::IHistogram2D*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::AIDA::IHistogram2D*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *AIDAcLcLIHistogram2D_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::AIDA::IHistogram2D*)0x0)->GetClass();
      AIDAcLcLIHistogram2D_TClassManip(theClass);
   return theClass;
   }

   static void AIDAcLcLIHistogram2D_TClassManip(TClass* ){
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *AIDAcLcLIHistogram3D_Dictionary();
   static void AIDAcLcLIHistogram3D_TClassManip(TClass*);
   static void delete_AIDAcLcLIHistogram3D(void *p);
   static void deleteArray_AIDAcLcLIHistogram3D(void *p);
   static void destruct_AIDAcLcLIHistogram3D(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::AIDA::IHistogram3D*)
   {
      ::AIDA::IHistogram3D *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::AIDA::IHistogram3D));
      static ::ROOT::TGenericClassInfo 
         instance("AIDA::IHistogram3D", "AIDA/IHistogram3D.h", 28,
                  typeid(::AIDA::IHistogram3D), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &AIDAcLcLIHistogram3D_Dictionary, isa_proxy, 4,
                  sizeof(::AIDA::IHistogram3D) );
      instance.SetDelete(&delete_AIDAcLcLIHistogram3D);
      instance.SetDeleteArray(&deleteArray_AIDAcLcLIHistogram3D);
      instance.SetDestructor(&destruct_AIDAcLcLIHistogram3D);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::AIDA::IHistogram3D*)
   {
      return GenerateInitInstanceLocal((::AIDA::IHistogram3D*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::AIDA::IHistogram3D*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *AIDAcLcLIHistogram3D_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::AIDA::IHistogram3D*)0x0)->GetClass();
      AIDAcLcLIHistogram3D_TClassManip(theClass);
   return theClass;
   }

   static void AIDAcLcLIHistogram3D_TClassManip(TClass* ){
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *AIDAcLcLIProfile_Dictionary();
   static void AIDAcLcLIProfile_TClassManip(TClass*);
   static void delete_AIDAcLcLIProfile(void *p);
   static void deleteArray_AIDAcLcLIProfile(void *p);
   static void destruct_AIDAcLcLIProfile(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::AIDA::IProfile*)
   {
      ::AIDA::IProfile *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::AIDA::IProfile));
      static ::ROOT::TGenericClassInfo 
         instance("AIDA::IProfile", "AIDA/IProfile.h", 26,
                  typeid(::AIDA::IProfile), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &AIDAcLcLIProfile_Dictionary, isa_proxy, 4,
                  sizeof(::AIDA::IProfile) );
      instance.SetDelete(&delete_AIDAcLcLIProfile);
      instance.SetDeleteArray(&deleteArray_AIDAcLcLIProfile);
      instance.SetDestructor(&destruct_AIDAcLcLIProfile);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::AIDA::IProfile*)
   {
      return GenerateInitInstanceLocal((::AIDA::IProfile*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::AIDA::IProfile*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *AIDAcLcLIProfile_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::AIDA::IProfile*)0x0)->GetClass();
      AIDAcLcLIProfile_TClassManip(theClass);
   return theClass;
   }

   static void AIDAcLcLIProfile_TClassManip(TClass* ){
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *AIDAcLcLIProfile1D_Dictionary();
   static void AIDAcLcLIProfile1D_TClassManip(TClass*);
   static void delete_AIDAcLcLIProfile1D(void *p);
   static void deleteArray_AIDAcLcLIProfile1D(void *p);
   static void destruct_AIDAcLcLIProfile1D(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::AIDA::IProfile1D*)
   {
      ::AIDA::IProfile1D *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::AIDA::IProfile1D));
      static ::ROOT::TGenericClassInfo 
         instance("AIDA::IProfile1D", "AIDA/IProfile1D.h", 28,
                  typeid(::AIDA::IProfile1D), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &AIDAcLcLIProfile1D_Dictionary, isa_proxy, 4,
                  sizeof(::AIDA::IProfile1D) );
      instance.SetDelete(&delete_AIDAcLcLIProfile1D);
      instance.SetDeleteArray(&deleteArray_AIDAcLcLIProfile1D);
      instance.SetDestructor(&destruct_AIDAcLcLIProfile1D);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::AIDA::IProfile1D*)
   {
      return GenerateInitInstanceLocal((::AIDA::IProfile1D*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::AIDA::IProfile1D*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *AIDAcLcLIProfile1D_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::AIDA::IProfile1D*)0x0)->GetClass();
      AIDAcLcLIProfile1D_TClassManip(theClass);
   return theClass;
   }

   static void AIDAcLcLIProfile1D_TClassManip(TClass* ){
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *AIDAcLcLIProfile2D_Dictionary();
   static void AIDAcLcLIProfile2D_TClassManip(TClass*);
   static void delete_AIDAcLcLIProfile2D(void *p);
   static void deleteArray_AIDAcLcLIProfile2D(void *p);
   static void destruct_AIDAcLcLIProfile2D(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::AIDA::IProfile2D*)
   {
      ::AIDA::IProfile2D *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::AIDA::IProfile2D));
      static ::ROOT::TGenericClassInfo 
         instance("AIDA::IProfile2D", "AIDA/IProfile2D.h", 28,
                  typeid(::AIDA::IProfile2D), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &AIDAcLcLIProfile2D_Dictionary, isa_proxy, 4,
                  sizeof(::AIDA::IProfile2D) );
      instance.SetDelete(&delete_AIDAcLcLIProfile2D);
      instance.SetDeleteArray(&deleteArray_AIDAcLcLIProfile2D);
      instance.SetDestructor(&destruct_AIDAcLcLIProfile2D);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::AIDA::IProfile2D*)
   {
      return GenerateInitInstanceLocal((::AIDA::IProfile2D*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::AIDA::IProfile2D*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *AIDAcLcLIProfile2D_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::AIDA::IProfile2D*)0x0)->GetClass();
      AIDAcLcLIProfile2D_TClassManip(theClass);
   return theClass;
   }

   static void AIDAcLcLIProfile2D_TClassManip(TClass* ){
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *GaudiPythoncLcLHelper_Dictionary();
   static void GaudiPythoncLcLHelper_TClassManip(TClass*);
   static void *new_GaudiPythoncLcLHelper(void *p = 0);
   static void *newArray_GaudiPythoncLcLHelper(Long_t size, void *p);
   static void delete_GaudiPythoncLcLHelper(void *p);
   static void deleteArray_GaudiPythoncLcLHelper(void *p);
   static void destruct_GaudiPythoncLcLHelper(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::GaudiPython::Helper*)
   {
      ::GaudiPython::Helper *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::GaudiPython::Helper));
      static ::ROOT::TGenericClassInfo 
         instance("GaudiPython::Helper", "GaudiPython/Helpers.h", 52,
                  typeid(::GaudiPython::Helper), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &GaudiPythoncLcLHelper_Dictionary, isa_proxy, 4,
                  sizeof(::GaudiPython::Helper) );
      instance.SetNew(&new_GaudiPythoncLcLHelper);
      instance.SetNewArray(&newArray_GaudiPythoncLcLHelper);
      instance.SetDelete(&delete_GaudiPythoncLcLHelper);
      instance.SetDeleteArray(&deleteArray_GaudiPythoncLcLHelper);
      instance.SetDestructor(&destruct_GaudiPythoncLcLHelper);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::GaudiPython::Helper*)
   {
      return GenerateInitInstanceLocal((::GaudiPython::Helper*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::GaudiPython::Helper*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *GaudiPythoncLcLHelper_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::GaudiPython::Helper*)0x0)->GetClass();
      GaudiPythoncLcLHelper_TClassManip(theClass);
   return theClass;
   }

   static void GaudiPythoncLcLHelper_TClassManip(TClass* ){
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *GaudiCommonlEAlgorithmgR_Dictionary();
   static void GaudiCommonlEAlgorithmgR_TClassManip(TClass*);
   static void delete_GaudiCommonlEAlgorithmgR(void *p);
   static void deleteArray_GaudiCommonlEAlgorithmgR(void *p);
   static void destruct_GaudiCommonlEAlgorithmgR(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::GaudiCommon<Algorithm>*)
   {
      ::GaudiCommon<Algorithm> *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::GaudiCommon<Algorithm>));
      static ::ROOT::TGenericClassInfo 
         instance("GaudiCommon<Algorithm>", "GaudiAlg/GaudiCommon.h", 93,
                  typeid(::GaudiCommon<Algorithm>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &GaudiCommonlEAlgorithmgR_Dictionary, isa_proxy, 4,
                  sizeof(::GaudiCommon<Algorithm>) );
      instance.SetDelete(&delete_GaudiCommonlEAlgorithmgR);
      instance.SetDeleteArray(&deleteArray_GaudiCommonlEAlgorithmgR);
      instance.SetDestructor(&destruct_GaudiCommonlEAlgorithmgR);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::GaudiCommon<Algorithm>*)
   {
      return GenerateInitInstanceLocal((::GaudiCommon<Algorithm>*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::GaudiCommon<Algorithm>*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *GaudiCommonlEAlgorithmgR_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::GaudiCommon<Algorithm>*)0x0)->GetClass();
      GaudiCommonlEAlgorithmgR_TClassManip(theClass);
   return theClass;
   }

   static void GaudiCommonlEAlgorithmgR_TClassManip(TClass* ){
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *GaudiCommonlEAlgToolgR_Dictionary();
   static void GaudiCommonlEAlgToolgR_TClassManip(TClass*);
   static void delete_GaudiCommonlEAlgToolgR(void *p);
   static void deleteArray_GaudiCommonlEAlgToolgR(void *p);
   static void destruct_GaudiCommonlEAlgToolgR(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::GaudiCommon<AlgTool>*)
   {
      ::GaudiCommon<AlgTool> *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::GaudiCommon<AlgTool>));
      static ::ROOT::TGenericClassInfo 
         instance("GaudiCommon<AlgTool>", "GaudiAlg/GaudiCommon.h", 93,
                  typeid(::GaudiCommon<AlgTool>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &GaudiCommonlEAlgToolgR_Dictionary, isa_proxy, 4,
                  sizeof(::GaudiCommon<AlgTool>) );
      instance.SetDelete(&delete_GaudiCommonlEAlgToolgR);
      instance.SetDeleteArray(&deleteArray_GaudiCommonlEAlgToolgR);
      instance.SetDestructor(&destruct_GaudiCommonlEAlgToolgR);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::GaudiCommon<AlgTool>*)
   {
      return GenerateInitInstanceLocal((::GaudiCommon<AlgTool>*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::GaudiCommon<AlgTool>*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *GaudiCommonlEAlgToolgR_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::GaudiCommon<AlgTool>*)0x0)->GetClass();
      GaudiCommonlEAlgToolgR_TClassManip(theClass);
   return theClass;
   }

   static void GaudiCommonlEAlgToolgR_TClassManip(TClass* ){
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *GaudiAlgorithm_Dictionary();
   static void GaudiAlgorithm_TClassManip(TClass*);
   static void delete_GaudiAlgorithm(void *p);
   static void deleteArray_GaudiAlgorithm(void *p);
   static void destruct_GaudiAlgorithm(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::GaudiAlgorithm*)
   {
      ::GaudiAlgorithm *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::GaudiAlgorithm));
      static ::ROOT::TGenericClassInfo 
         instance("GaudiAlgorithm", "GaudiAlg/GaudiAlgorithm.h", 94,
                  typeid(::GaudiAlgorithm), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &GaudiAlgorithm_Dictionary, isa_proxy, 4,
                  sizeof(::GaudiAlgorithm) );
      instance.SetDelete(&delete_GaudiAlgorithm);
      instance.SetDeleteArray(&deleteArray_GaudiAlgorithm);
      instance.SetDestructor(&destruct_GaudiAlgorithm);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::GaudiAlgorithm*)
   {
      return GenerateInitInstanceLocal((::GaudiAlgorithm*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::GaudiAlgorithm*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *GaudiAlgorithm_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::GaudiAlgorithm*)0x0)->GetClass();
      GaudiAlgorithm_TClassManip(theClass);
   return theClass;
   }

   static void GaudiAlgorithm_TClassManip(TClass* ){
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *GaudiPythoncLcLAlgDecorator_Dictionary();
   static void GaudiPythoncLcLAlgDecorator_TClassManip(TClass*);
   static void *new_GaudiPythoncLcLAlgDecorator(void *p = 0);
   static void *newArray_GaudiPythoncLcLAlgDecorator(Long_t size, void *p);
   static void delete_GaudiPythoncLcLAlgDecorator(void *p);
   static void deleteArray_GaudiPythoncLcLAlgDecorator(void *p);
   static void destruct_GaudiPythoncLcLAlgDecorator(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::GaudiPython::AlgDecorator*)
   {
      ::GaudiPython::AlgDecorator *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::GaudiPython::AlgDecorator));
      static ::ROOT::TGenericClassInfo 
         instance("GaudiPython::AlgDecorator", "GaudiPython/AlgDecorators.h", 46,
                  typeid(::GaudiPython::AlgDecorator), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &GaudiPythoncLcLAlgDecorator_Dictionary, isa_proxy, 4,
                  sizeof(::GaudiPython::AlgDecorator) );
      instance.SetNew(&new_GaudiPythoncLcLAlgDecorator);
      instance.SetNewArray(&newArray_GaudiPythoncLcLAlgDecorator);
      instance.SetDelete(&delete_GaudiPythoncLcLAlgDecorator);
      instance.SetDeleteArray(&deleteArray_GaudiPythoncLcLAlgDecorator);
      instance.SetDestructor(&destruct_GaudiPythoncLcLAlgDecorator);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::GaudiPython::AlgDecorator*)
   {
      return GenerateInitInstanceLocal((::GaudiPython::AlgDecorator*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::GaudiPython::AlgDecorator*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *GaudiPythoncLcLAlgDecorator_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::GaudiPython::AlgDecorator*)0x0)->GetClass();
      GaudiPythoncLcLAlgDecorator_TClassManip(theClass);
   return theClass;
   }

   static void GaudiPythoncLcLAlgDecorator_TClassManip(TClass* ){
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *GaudiPythoncLcLPyAlgorithm_Dictionary();
   static void GaudiPythoncLcLPyAlgorithm_TClassManip(TClass*);
   static void delete_GaudiPythoncLcLPyAlgorithm(void *p);
   static void deleteArray_GaudiPythoncLcLPyAlgorithm(void *p);
   static void destruct_GaudiPythoncLcLPyAlgorithm(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::GaudiPython::PyAlgorithm*)
   {
      ::GaudiPython::PyAlgorithm *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::GaudiPython::PyAlgorithm));
      static ::ROOT::TGenericClassInfo 
         instance("GaudiPython::PyAlgorithm", "GaudiPython/Algorithm.h", 32,
                  typeid(::GaudiPython::PyAlgorithm), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &GaudiPythoncLcLPyAlgorithm_Dictionary, isa_proxy, 4,
                  sizeof(::GaudiPython::PyAlgorithm) );
      instance.SetDelete(&delete_GaudiPythoncLcLPyAlgorithm);
      instance.SetDeleteArray(&deleteArray_GaudiPythoncLcLPyAlgorithm);
      instance.SetDestructor(&destruct_GaudiPythoncLcLPyAlgorithm);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::GaudiPython::PyAlgorithm*)
   {
      return GenerateInitInstanceLocal((::GaudiPython::PyAlgorithm*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::GaudiPython::PyAlgorithm*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *GaudiPythoncLcLPyAlgorithm_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::GaudiPython::PyAlgorithm*)0x0)->GetClass();
      GaudiPythoncLcLPyAlgorithm_TClassManip(theClass);
   return theClass;
   }

   static void GaudiPythoncLcLPyAlgorithm_TClassManip(TClass* ){
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *GaudiPythoncLcLPyAlglEGaudiAlgorithmgR_Dictionary();
   static void GaudiPythoncLcLPyAlglEGaudiAlgorithmgR_TClassManip(TClass*);
   static void delete_GaudiPythoncLcLPyAlglEGaudiAlgorithmgR(void *p);
   static void deleteArray_GaudiPythoncLcLPyAlglEGaudiAlgorithmgR(void *p);
   static void destruct_GaudiPythoncLcLPyAlglEGaudiAlgorithmgR(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::GaudiPython::PyAlg<GaudiAlgorithm>*)
   {
      ::GaudiPython::PyAlg<GaudiAlgorithm> *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::GaudiPython::PyAlg<GaudiAlgorithm>));
      static ::ROOT::TGenericClassInfo 
         instance("GaudiPython::PyAlg<GaudiAlgorithm>", "GaudiPython/Algorithm.h", 62,
                  typeid(::GaudiPython::PyAlg<GaudiAlgorithm>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &GaudiPythoncLcLPyAlglEGaudiAlgorithmgR_Dictionary, isa_proxy, 4,
                  sizeof(::GaudiPython::PyAlg<GaudiAlgorithm>) );
      instance.SetDelete(&delete_GaudiPythoncLcLPyAlglEGaudiAlgorithmgR);
      instance.SetDeleteArray(&deleteArray_GaudiPythoncLcLPyAlglEGaudiAlgorithmgR);
      instance.SetDestructor(&destruct_GaudiPythoncLcLPyAlglEGaudiAlgorithmgR);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::GaudiPython::PyAlg<GaudiAlgorithm>*)
   {
      return GenerateInitInstanceLocal((::GaudiPython::PyAlg<GaudiAlgorithm>*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::GaudiPython::PyAlg<GaudiAlgorithm>*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *GaudiPythoncLcLPyAlglEGaudiAlgorithmgR_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::GaudiPython::PyAlg<GaudiAlgorithm>*)0x0)->GetClass();
      GaudiPythoncLcLPyAlglEGaudiAlgorithmgR_TClassManip(theClass);
   return theClass;
   }

   static void GaudiPythoncLcLPyAlglEGaudiAlgorithmgR_TClassManip(TClass* ){
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *GaudiPythoncLcLPyAlglEGaudiHistoAlggR_Dictionary();
   static void GaudiPythoncLcLPyAlglEGaudiHistoAlggR_TClassManip(TClass*);
   static void delete_GaudiPythoncLcLPyAlglEGaudiHistoAlggR(void *p);
   static void deleteArray_GaudiPythoncLcLPyAlglEGaudiHistoAlggR(void *p);
   static void destruct_GaudiPythoncLcLPyAlglEGaudiHistoAlggR(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::GaudiPython::PyAlg<GaudiHistoAlg>*)
   {
      ::GaudiPython::PyAlg<GaudiHistoAlg> *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::GaudiPython::PyAlg<GaudiHistoAlg>));
      static ::ROOT::TGenericClassInfo 
         instance("GaudiPython::PyAlg<GaudiHistoAlg>", "GaudiPython/Algorithm.h", 62,
                  typeid(::GaudiPython::PyAlg<GaudiHistoAlg>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &GaudiPythoncLcLPyAlglEGaudiHistoAlggR_Dictionary, isa_proxy, 4,
                  sizeof(::GaudiPython::PyAlg<GaudiHistoAlg>) );
      instance.SetDelete(&delete_GaudiPythoncLcLPyAlglEGaudiHistoAlggR);
      instance.SetDeleteArray(&deleteArray_GaudiPythoncLcLPyAlglEGaudiHistoAlggR);
      instance.SetDestructor(&destruct_GaudiPythoncLcLPyAlglEGaudiHistoAlggR);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::GaudiPython::PyAlg<GaudiHistoAlg>*)
   {
      return GenerateInitInstanceLocal((::GaudiPython::PyAlg<GaudiHistoAlg>*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::GaudiPython::PyAlg<GaudiHistoAlg>*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *GaudiPythoncLcLPyAlglEGaudiHistoAlggR_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::GaudiPython::PyAlg<GaudiHistoAlg>*)0x0)->GetClass();
      GaudiPythoncLcLPyAlglEGaudiHistoAlggR_TClassManip(theClass);
   return theClass;
   }

   static void GaudiPythoncLcLPyAlglEGaudiHistoAlggR_TClassManip(TClass* ){
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *GaudiPythoncLcLPyAlglEGaudiTupleAlggR_Dictionary();
   static void GaudiPythoncLcLPyAlglEGaudiTupleAlggR_TClassManip(TClass*);
   static void delete_GaudiPythoncLcLPyAlglEGaudiTupleAlggR(void *p);
   static void deleteArray_GaudiPythoncLcLPyAlglEGaudiTupleAlggR(void *p);
   static void destruct_GaudiPythoncLcLPyAlglEGaudiTupleAlggR(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::GaudiPython::PyAlg<GaudiTupleAlg>*)
   {
      ::GaudiPython::PyAlg<GaudiTupleAlg> *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::GaudiPython::PyAlg<GaudiTupleAlg>));
      static ::ROOT::TGenericClassInfo 
         instance("GaudiPython::PyAlg<GaudiTupleAlg>", "GaudiPython/Algorithm.h", 62,
                  typeid(::GaudiPython::PyAlg<GaudiTupleAlg>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &GaudiPythoncLcLPyAlglEGaudiTupleAlggR_Dictionary, isa_proxy, 4,
                  sizeof(::GaudiPython::PyAlg<GaudiTupleAlg>) );
      instance.SetDelete(&delete_GaudiPythoncLcLPyAlglEGaudiTupleAlggR);
      instance.SetDeleteArray(&deleteArray_GaudiPythoncLcLPyAlglEGaudiTupleAlggR);
      instance.SetDestructor(&destruct_GaudiPythoncLcLPyAlglEGaudiTupleAlggR);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::GaudiPython::PyAlg<GaudiTupleAlg>*)
   {
      return GenerateInitInstanceLocal((::GaudiPython::PyAlg<GaudiTupleAlg>*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::GaudiPython::PyAlg<GaudiTupleAlg>*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *GaudiPythoncLcLPyAlglEGaudiTupleAlggR_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::GaudiPython::PyAlg<GaudiTupleAlg>*)0x0)->GetClass();
      GaudiPythoncLcLPyAlglEGaudiTupleAlggR_TClassManip(theClass);
   return theClass;
   }

   static void GaudiPythoncLcLPyAlglEGaudiTupleAlggR_TClassManip(TClass* ){
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *GaudiPythoncLcLCallbackStreamBuf_Dictionary();
   static void GaudiPythoncLcLCallbackStreamBuf_TClassManip(TClass*);
   static void delete_GaudiPythoncLcLCallbackStreamBuf(void *p);
   static void deleteArray_GaudiPythoncLcLCallbackStreamBuf(void *p);
   static void destruct_GaudiPythoncLcLCallbackStreamBuf(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::GaudiPython::CallbackStreamBuf*)
   {
      ::GaudiPython::CallbackStreamBuf *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::GaudiPython::CallbackStreamBuf));
      static ::ROOT::TGenericClassInfo 
         instance("GaudiPython::CallbackStreamBuf", "GaudiPython/CallbackStreamBuf.h", 17,
                  typeid(::GaudiPython::CallbackStreamBuf), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &GaudiPythoncLcLCallbackStreamBuf_Dictionary, isa_proxy, 4,
                  sizeof(::GaudiPython::CallbackStreamBuf) );
      instance.SetDelete(&delete_GaudiPythoncLcLCallbackStreamBuf);
      instance.SetDeleteArray(&deleteArray_GaudiPythoncLcLCallbackStreamBuf);
      instance.SetDestructor(&destruct_GaudiPythoncLcLCallbackStreamBuf);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::GaudiPython::CallbackStreamBuf*)
   {
      return GenerateInitInstanceLocal((::GaudiPython::CallbackStreamBuf*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::GaudiPython::CallbackStreamBuf*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *GaudiPythoncLcLCallbackStreamBuf_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::GaudiPython::CallbackStreamBuf*)0x0)->GetClass();
      GaudiPythoncLcLCallbackStreamBuf_TClassManip(theClass);
   return theClass;
   }

   static void GaudiPythoncLcLCallbackStreamBuf_TClassManip(TClass* ){
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *GaudicLcLUtilscLcLHistoscLcLTable_Dictionary();
   static void GaudicLcLUtilscLcLHistoscLcLTable_TClassManip(TClass*);
   static void *new_GaudicLcLUtilscLcLHistoscLcLTable(void *p = 0);
   static void *newArray_GaudicLcLUtilscLcLHistoscLcLTable(Long_t size, void *p);
   static void delete_GaudicLcLUtilscLcLHistoscLcLTable(void *p);
   static void deleteArray_GaudicLcLUtilscLcLHistoscLcLTable(void *p);
   static void destruct_GaudicLcLUtilscLcLHistoscLcLTable(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::Gaudi::Utils::Histos::Table*)
   {
      ::Gaudi::Utils::Histos::Table *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::Gaudi::Utils::Histos::Table));
      static ::ROOT::TGenericClassInfo 
         instance("Gaudi::Utils::Histos::Table", "GaudiUtils/HistoTableFormat.h", 381,
                  typeid(::Gaudi::Utils::Histos::Table), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &GaudicLcLUtilscLcLHistoscLcLTable_Dictionary, isa_proxy, 4,
                  sizeof(::Gaudi::Utils::Histos::Table) );
      instance.SetNew(&new_GaudicLcLUtilscLcLHistoscLcLTable);
      instance.SetNewArray(&newArray_GaudicLcLUtilscLcLHistoscLcLTable);
      instance.SetDelete(&delete_GaudicLcLUtilscLcLHistoscLcLTable);
      instance.SetDeleteArray(&deleteArray_GaudicLcLUtilscLcLHistoscLcLTable);
      instance.SetDestructor(&destruct_GaudicLcLUtilscLcLHistoscLcLTable);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::Gaudi::Utils::Histos::Table*)
   {
      return GenerateInitInstanceLocal((::Gaudi::Utils::Histos::Table*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::Gaudi::Utils::Histos::Table*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *GaudicLcLUtilscLcLHistoscLcLTable_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::Gaudi::Utils::Histos::Table*)0x0)->GetClass();
      GaudicLcLUtilscLcLHistoscLcLTable_TClassManip(theClass);
   return theClass;
   }

   static void GaudicLcLUtilscLcLHistoscLcLTable_TClassManip(TClass* ){
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *GaudiAlgcLcLID_Dictionary();
   static void GaudiAlgcLcLID_TClassManip(TClass*);
   static void *new_GaudiAlgcLcLID(void *p = 0);
   static void *newArray_GaudiAlgcLcLID(Long_t size, void *p);
   static void delete_GaudiAlgcLcLID(void *p);
   static void deleteArray_GaudiAlgcLcLID(void *p);
   static void destruct_GaudiAlgcLcLID(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::GaudiAlg::ID*)
   {
      ::GaudiAlg::ID *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::GaudiAlg::ID));
      static ::ROOT::TGenericClassInfo 
         instance("GaudiAlg::ID", "GaudiAlg/GaudiHistoID.h", 44,
                  typeid(::GaudiAlg::ID), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &GaudiAlgcLcLID_Dictionary, isa_proxy, 4,
                  sizeof(::GaudiAlg::ID) );
      instance.SetNew(&new_GaudiAlgcLcLID);
      instance.SetNewArray(&newArray_GaudiAlgcLcLID);
      instance.SetDelete(&delete_GaudiAlgcLcLID);
      instance.SetDeleteArray(&deleteArray_GaudiAlgcLcLID);
      instance.SetDestructor(&destruct_GaudiAlgcLcLID);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::GaudiAlg::ID*)
   {
      return GenerateInitInstanceLocal((::GaudiAlg::ID*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::GaudiAlg::ID*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *GaudiAlgcLcLID_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::GaudiAlg::ID*)0x0)->GetClass();
      GaudiAlgcLcLID_TClassManip(theClass);
   return theClass;
   }

   static void GaudiAlgcLcLID_TClassManip(TClass* ){
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *GaudiHistoslEGaudiAlgorithmgR_Dictionary();
   static void GaudiHistoslEGaudiAlgorithmgR_TClassManip(TClass*);
   static void delete_GaudiHistoslEGaudiAlgorithmgR(void *p);
   static void deleteArray_GaudiHistoslEGaudiAlgorithmgR(void *p);
   static void destruct_GaudiHistoslEGaudiAlgorithmgR(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::GaudiHistos<GaudiAlgorithm>*)
   {
      ::GaudiHistos<GaudiAlgorithm> *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::GaudiHistos<GaudiAlgorithm>));
      static ::ROOT::TGenericClassInfo 
         instance("GaudiHistos<GaudiAlgorithm>", "GaudiAlg/GaudiHistos.h", 56,
                  typeid(::GaudiHistos<GaudiAlgorithm>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &GaudiHistoslEGaudiAlgorithmgR_Dictionary, isa_proxy, 4,
                  sizeof(::GaudiHistos<GaudiAlgorithm>) );
      instance.SetDelete(&delete_GaudiHistoslEGaudiAlgorithmgR);
      instance.SetDeleteArray(&deleteArray_GaudiHistoslEGaudiAlgorithmgR);
      instance.SetDestructor(&destruct_GaudiHistoslEGaudiAlgorithmgR);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::GaudiHistos<GaudiAlgorithm>*)
   {
      return GenerateInitInstanceLocal((::GaudiHistos<GaudiAlgorithm>*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::GaudiHistos<GaudiAlgorithm>*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *GaudiHistoslEGaudiAlgorithmgR_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::GaudiHistos<GaudiAlgorithm>*)0x0)->GetClass();
      GaudiHistoslEGaudiAlgorithmgR_TClassManip(theClass);
   return theClass;
   }

   static void GaudiHistoslEGaudiAlgorithmgR_TClassManip(TClass* ){
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *GaudiHistoslEGaudiToolgR_Dictionary();
   static void GaudiHistoslEGaudiToolgR_TClassManip(TClass*);
   static void delete_GaudiHistoslEGaudiToolgR(void *p);
   static void deleteArray_GaudiHistoslEGaudiToolgR(void *p);
   static void destruct_GaudiHistoslEGaudiToolgR(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::GaudiHistos<GaudiTool>*)
   {
      ::GaudiHistos<GaudiTool> *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::GaudiHistos<GaudiTool>));
      static ::ROOT::TGenericClassInfo 
         instance("GaudiHistos<GaudiTool>", "GaudiAlg/GaudiHistos.h", 56,
                  typeid(::GaudiHistos<GaudiTool>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &GaudiHistoslEGaudiToolgR_Dictionary, isa_proxy, 4,
                  sizeof(::GaudiHistos<GaudiTool>) );
      instance.SetDelete(&delete_GaudiHistoslEGaudiToolgR);
      instance.SetDeleteArray(&deleteArray_GaudiHistoslEGaudiToolgR);
      instance.SetDestructor(&destruct_GaudiHistoslEGaudiToolgR);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::GaudiHistos<GaudiTool>*)
   {
      return GenerateInitInstanceLocal((::GaudiHistos<GaudiTool>*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::GaudiHistos<GaudiTool>*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *GaudiHistoslEGaudiToolgR_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::GaudiHistos<GaudiTool>*)0x0)->GetClass();
      GaudiHistoslEGaudiToolgR_TClassManip(theClass);
   return theClass;
   }

   static void GaudiHistoslEGaudiToolgR_TClassManip(TClass* ){
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *GaudiPythoncLcLHistoDecorator_Dictionary();
   static void GaudiPythoncLcLHistoDecorator_TClassManip(TClass*);
   static void *new_GaudiPythoncLcLHistoDecorator(void *p = 0);
   static void *newArray_GaudiPythoncLcLHistoDecorator(Long_t size, void *p);
   static void delete_GaudiPythoncLcLHistoDecorator(void *p);
   static void deleteArray_GaudiPythoncLcLHistoDecorator(void *p);
   static void destruct_GaudiPythoncLcLHistoDecorator(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::GaudiPython::HistoDecorator*)
   {
      ::GaudiPython::HistoDecorator *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::GaudiPython::HistoDecorator));
      static ::ROOT::TGenericClassInfo 
         instance("GaudiPython::HistoDecorator", "GaudiPython/HistoDecorator.h", 26,
                  typeid(::GaudiPython::HistoDecorator), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &GaudiPythoncLcLHistoDecorator_Dictionary, isa_proxy, 4,
                  sizeof(::GaudiPython::HistoDecorator) );
      instance.SetNew(&new_GaudiPythoncLcLHistoDecorator);
      instance.SetNewArray(&newArray_GaudiPythoncLcLHistoDecorator);
      instance.SetDelete(&delete_GaudiPythoncLcLHistoDecorator);
      instance.SetDeleteArray(&deleteArray_GaudiPythoncLcLHistoDecorator);
      instance.SetDestructor(&destruct_GaudiPythoncLcLHistoDecorator);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::GaudiPython::HistoDecorator*)
   {
      return GenerateInitInstanceLocal((::GaudiPython::HistoDecorator*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::GaudiPython::HistoDecorator*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *GaudiPythoncLcLHistoDecorator_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::GaudiPython::HistoDecorator*)0x0)->GetClass();
      GaudiPythoncLcLHistoDecorator_TClassManip(theClass);
   return theClass;
   }

   static void GaudiPythoncLcLHistoDecorator_TClassManip(TClass* ){
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *GaudiPythoncLcLPrinterlEContainedObjectgR_Dictionary();
   static void GaudiPythoncLcLPrinterlEContainedObjectgR_TClassManip(TClass*);
   static void *new_GaudiPythoncLcLPrinterlEContainedObjectgR(void *p = 0);
   static void *newArray_GaudiPythoncLcLPrinterlEContainedObjectgR(Long_t size, void *p);
   static void delete_GaudiPythoncLcLPrinterlEContainedObjectgR(void *p);
   static void deleteArray_GaudiPythoncLcLPrinterlEContainedObjectgR(void *p);
   static void destruct_GaudiPythoncLcLPrinterlEContainedObjectgR(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::GaudiPython::Printer<ContainedObject>*)
   {
      ::GaudiPython::Printer<ContainedObject> *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::GaudiPython::Printer<ContainedObject>));
      static ::ROOT::TGenericClassInfo 
         instance("GaudiPython::Printer<ContainedObject>", "GaudiPython/Printer.h", 35,
                  typeid(::GaudiPython::Printer<ContainedObject>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &GaudiPythoncLcLPrinterlEContainedObjectgR_Dictionary, isa_proxy, 4,
                  sizeof(::GaudiPython::Printer<ContainedObject>) );
      instance.SetNew(&new_GaudiPythoncLcLPrinterlEContainedObjectgR);
      instance.SetNewArray(&newArray_GaudiPythoncLcLPrinterlEContainedObjectgR);
      instance.SetDelete(&delete_GaudiPythoncLcLPrinterlEContainedObjectgR);
      instance.SetDeleteArray(&deleteArray_GaudiPythoncLcLPrinterlEContainedObjectgR);
      instance.SetDestructor(&destruct_GaudiPythoncLcLPrinterlEContainedObjectgR);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::GaudiPython::Printer<ContainedObject>*)
   {
      return GenerateInitInstanceLocal((::GaudiPython::Printer<ContainedObject>*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::GaudiPython::Printer<ContainedObject>*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *GaudiPythoncLcLPrinterlEContainedObjectgR_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::GaudiPython::Printer<ContainedObject>*)0x0)->GetClass();
      GaudiPythoncLcLPrinterlEContainedObjectgR_TClassManip(theClass);
   return theClass;
   }

   static void GaudiPythoncLcLPrinterlEContainedObjectgR_TClassManip(TClass* ){
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *GaudiPythoncLcLPrinterlEDataObjectgR_Dictionary();
   static void GaudiPythoncLcLPrinterlEDataObjectgR_TClassManip(TClass*);
   static void *new_GaudiPythoncLcLPrinterlEDataObjectgR(void *p = 0);
   static void *newArray_GaudiPythoncLcLPrinterlEDataObjectgR(Long_t size, void *p);
   static void delete_GaudiPythoncLcLPrinterlEDataObjectgR(void *p);
   static void deleteArray_GaudiPythoncLcLPrinterlEDataObjectgR(void *p);
   static void destruct_GaudiPythoncLcLPrinterlEDataObjectgR(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::GaudiPython::Printer<DataObject>*)
   {
      ::GaudiPython::Printer<DataObject> *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::GaudiPython::Printer<DataObject>));
      static ::ROOT::TGenericClassInfo 
         instance("GaudiPython::Printer<DataObject>", "GaudiPython/Printer.h", 44,
                  typeid(::GaudiPython::Printer<DataObject>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &GaudiPythoncLcLPrinterlEDataObjectgR_Dictionary, isa_proxy, 4,
                  sizeof(::GaudiPython::Printer<DataObject>) );
      instance.SetNew(&new_GaudiPythoncLcLPrinterlEDataObjectgR);
      instance.SetNewArray(&newArray_GaudiPythoncLcLPrinterlEDataObjectgR);
      instance.SetDelete(&delete_GaudiPythoncLcLPrinterlEDataObjectgR);
      instance.SetDeleteArray(&deleteArray_GaudiPythoncLcLPrinterlEDataObjectgR);
      instance.SetDestructor(&destruct_GaudiPythoncLcLPrinterlEDataObjectgR);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::GaudiPython::Printer<DataObject>*)
   {
      return GenerateInitInstanceLocal((::GaudiPython::Printer<DataObject>*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::GaudiPython::Printer<DataObject>*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *GaudiPythoncLcLPrinterlEDataObjectgR_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::GaudiPython::Printer<DataObject>*)0x0)->GetClass();
      GaudiPythoncLcLPrinterlEDataObjectgR_TClassManip(theClass);
   return theClass;
   }

   static void GaudiPythoncLcLPrinterlEDataObjectgR_TClassManip(TClass* ){
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *TuplescLcLTuple_Dictionary();
   static void TuplescLcLTuple_TClassManip(TClass*);
   static void delete_TuplescLcLTuple(void *p);
   static void deleteArray_TuplescLcLTuple(void *p);
   static void destruct_TuplescLcLTuple(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::Tuples::Tuple*)
   {
      ::Tuples::Tuple *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::Tuples::Tuple));
      static ::ROOT::TGenericClassInfo 
         instance("Tuples::Tuple", "GaudiAlg/Tuple.h", 117,
                  typeid(::Tuples::Tuple), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &TuplescLcLTuple_Dictionary, isa_proxy, 4,
                  sizeof(::Tuples::Tuple) );
      instance.SetDelete(&delete_TuplescLcLTuple);
      instance.SetDeleteArray(&deleteArray_TuplescLcLTuple);
      instance.SetDestructor(&destruct_TuplescLcLTuple);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::Tuples::Tuple*)
   {
      return GenerateInitInstanceLocal((::Tuples::Tuple*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::Tuples::Tuple*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *TuplescLcLTuple_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::Tuples::Tuple*)0x0)->GetClass();
      TuplescLcLTuple_TClassManip(theClass);
   return theClass;
   }

   static void TuplescLcLTuple_TClassManip(TClass* ){
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *GaudiTupleslEGaudiHistoAlggR_Dictionary();
   static void GaudiTupleslEGaudiHistoAlggR_TClassManip(TClass*);
   static void delete_GaudiTupleslEGaudiHistoAlggR(void *p);
   static void deleteArray_GaudiTupleslEGaudiHistoAlggR(void *p);
   static void destruct_GaudiTupleslEGaudiHistoAlggR(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::GaudiTuples<GaudiHistoAlg>*)
   {
      ::GaudiTuples<GaudiHistoAlg> *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::GaudiTuples<GaudiHistoAlg>));
      static ::ROOT::TGenericClassInfo 
         instance("GaudiTuples<GaudiHistoAlg>", "GaudiAlg/GaudiTuples.h", 43,
                  typeid(::GaudiTuples<GaudiHistoAlg>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &GaudiTupleslEGaudiHistoAlggR_Dictionary, isa_proxy, 4,
                  sizeof(::GaudiTuples<GaudiHistoAlg>) );
      instance.SetDelete(&delete_GaudiTupleslEGaudiHistoAlggR);
      instance.SetDeleteArray(&deleteArray_GaudiTupleslEGaudiHistoAlggR);
      instance.SetDestructor(&destruct_GaudiTupleslEGaudiHistoAlggR);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::GaudiTuples<GaudiHistoAlg>*)
   {
      return GenerateInitInstanceLocal((::GaudiTuples<GaudiHistoAlg>*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::GaudiTuples<GaudiHistoAlg>*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *GaudiTupleslEGaudiHistoAlggR_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::GaudiTuples<GaudiHistoAlg>*)0x0)->GetClass();
      GaudiTupleslEGaudiHistoAlggR_TClassManip(theClass);
   return theClass;
   }

   static void GaudiTupleslEGaudiHistoAlggR_TClassManip(TClass* ){
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *ITupleTool_Dictionary();
   static void ITupleTool_TClassManip(TClass*);
   static void delete_ITupleTool(void *p);
   static void deleteArray_ITupleTool(void *p);
   static void destruct_ITupleTool(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::ITupleTool*)
   {
      ::ITupleTool *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::ITupleTool));
      static ::ROOT::TGenericClassInfo 
         instance("ITupleTool", "GaudiAlg/ITupleTool.h", 30,
                  typeid(::ITupleTool), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &ITupleTool_Dictionary, isa_proxy, 4,
                  sizeof(::ITupleTool) );
      instance.SetDelete(&delete_ITupleTool);
      instance.SetDeleteArray(&deleteArray_ITupleTool);
      instance.SetDestructor(&destruct_ITupleTool);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::ITupleTool*)
   {
      return GenerateInitInstanceLocal((::ITupleTool*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::ITupleTool*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *ITupleTool_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::ITupleTool*)0x0)->GetClass();
      ITupleTool_TClassManip(theClass);
   return theClass;
   }

   static void ITupleTool_TClassManip(TClass* ){
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *GaudiPythoncLcLTupleDecorator_Dictionary();
   static void GaudiPythoncLcLTupleDecorator_TClassManip(TClass*);
   static void *new_GaudiPythoncLcLTupleDecorator(void *p = 0);
   static void *newArray_GaudiPythoncLcLTupleDecorator(Long_t size, void *p);
   static void delete_GaudiPythoncLcLTupleDecorator(void *p);
   static void deleteArray_GaudiPythoncLcLTupleDecorator(void *p);
   static void destruct_GaudiPythoncLcLTupleDecorator(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::GaudiPython::TupleDecorator*)
   {
      ::GaudiPython::TupleDecorator *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::GaudiPython::TupleDecorator));
      static ::ROOT::TGenericClassInfo 
         instance("GaudiPython::TupleDecorator", "GaudiPython/TupleDecorator.h", 46,
                  typeid(::GaudiPython::TupleDecorator), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &GaudiPythoncLcLTupleDecorator_Dictionary, isa_proxy, 4,
                  sizeof(::GaudiPython::TupleDecorator) );
      instance.SetNew(&new_GaudiPythoncLcLTupleDecorator);
      instance.SetNewArray(&newArray_GaudiPythoncLcLTupleDecorator);
      instance.SetDelete(&delete_GaudiPythoncLcLTupleDecorator);
      instance.SetDeleteArray(&deleteArray_GaudiPythoncLcLTupleDecorator);
      instance.SetDestructor(&destruct_GaudiPythoncLcLTupleDecorator);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::GaudiPython::TupleDecorator*)
   {
      return GenerateInitInstanceLocal((::GaudiPython::TupleDecorator*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::GaudiPython::TupleDecorator*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *GaudiPythoncLcLTupleDecorator_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::GaudiPython::TupleDecorator*)0x0)->GetClass();
      GaudiPythoncLcLTupleDecorator_TClassManip(theClass);
   return theClass;
   }

   static void GaudiPythoncLcLTupleDecorator_TClassManip(TClass* ){
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *GaudiPythoncLcLTupleAlgDecorator_Dictionary();
   static void GaudiPythoncLcLTupleAlgDecorator_TClassManip(TClass*);
   static void *new_GaudiPythoncLcLTupleAlgDecorator(void *p = 0);
   static void *newArray_GaudiPythoncLcLTupleAlgDecorator(Long_t size, void *p);
   static void delete_GaudiPythoncLcLTupleAlgDecorator(void *p);
   static void deleteArray_GaudiPythoncLcLTupleAlgDecorator(void *p);
   static void destruct_GaudiPythoncLcLTupleAlgDecorator(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::GaudiPython::TupleAlgDecorator*)
   {
      ::GaudiPython::TupleAlgDecorator *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::GaudiPython::TupleAlgDecorator));
      static ::ROOT::TGenericClassInfo 
         instance("GaudiPython::TupleAlgDecorator", "GaudiPython/TupleDecorator.h", 269,
                  typeid(::GaudiPython::TupleAlgDecorator), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &GaudiPythoncLcLTupleAlgDecorator_Dictionary, isa_proxy, 4,
                  sizeof(::GaudiPython::TupleAlgDecorator) );
      instance.SetNew(&new_GaudiPythoncLcLTupleAlgDecorator);
      instance.SetNewArray(&newArray_GaudiPythoncLcLTupleAlgDecorator);
      instance.SetDelete(&delete_GaudiPythoncLcLTupleAlgDecorator);
      instance.SetDeleteArray(&deleteArray_GaudiPythoncLcLTupleAlgDecorator);
      instance.SetDestructor(&destruct_GaudiPythoncLcLTupleAlgDecorator);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::GaudiPython::TupleAlgDecorator*)
   {
      return GenerateInitInstanceLocal((::GaudiPython::TupleAlgDecorator*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::GaudiPython::TupleAlgDecorator*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *GaudiPythoncLcLTupleAlgDecorator_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::GaudiPython::TupleAlgDecorator*)0x0)->GetClass();
      GaudiPythoncLcLTupleAlgDecorator_TClassManip(theClass);
   return theClass;
   }

   static void GaudiPythoncLcLTupleAlgDecorator_TClassManip(TClass* ){
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *GaudiPythoncLcLTupleToolDecorator_Dictionary();
   static void GaudiPythoncLcLTupleToolDecorator_TClassManip(TClass*);
   static void *new_GaudiPythoncLcLTupleToolDecorator(void *p = 0);
   static void *newArray_GaudiPythoncLcLTupleToolDecorator(Long_t size, void *p);
   static void delete_GaudiPythoncLcLTupleToolDecorator(void *p);
   static void deleteArray_GaudiPythoncLcLTupleToolDecorator(void *p);
   static void destruct_GaudiPythoncLcLTupleToolDecorator(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::GaudiPython::TupleToolDecorator*)
   {
      ::GaudiPython::TupleToolDecorator *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::GaudiPython::TupleToolDecorator));
      static ::ROOT::TGenericClassInfo 
         instance("GaudiPython::TupleToolDecorator", "GaudiPython/TupleDecorator.h", 312,
                  typeid(::GaudiPython::TupleToolDecorator), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &GaudiPythoncLcLTupleToolDecorator_Dictionary, isa_proxy, 4,
                  sizeof(::GaudiPython::TupleToolDecorator) );
      instance.SetNew(&new_GaudiPythoncLcLTupleToolDecorator);
      instance.SetNewArray(&newArray_GaudiPythoncLcLTupleToolDecorator);
      instance.SetDelete(&delete_GaudiPythoncLcLTupleToolDecorator);
      instance.SetDeleteArray(&deleteArray_GaudiPythoncLcLTupleToolDecorator);
      instance.SetDestructor(&destruct_GaudiPythoncLcLTupleToolDecorator);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::GaudiPython::TupleToolDecorator*)
   {
      return GenerateInitInstanceLocal((::GaudiPython::TupleToolDecorator*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::GaudiPython::TupleToolDecorator*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *GaudiPythoncLcLTupleToolDecorator_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::GaudiPython::TupleToolDecorator*)0x0)->GetClass();
      GaudiPythoncLcLTupleToolDecorator_TClassManip(theClass);
   return theClass;
   }

   static void GaudiPythoncLcLTupleToolDecorator_TClassManip(TClass* ){
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *GaudiAlgcLcLPrint_Dictionary();
   static void GaudiAlgcLcLPrint_TClassManip(TClass*);
   static void *new_GaudiAlgcLcLPrint(void *p = 0);
   static void *newArray_GaudiAlgcLcLPrint(Long_t size, void *p);
   static void delete_GaudiAlgcLcLPrint(void *p);
   static void deleteArray_GaudiAlgcLcLPrint(void *p);
   static void destruct_GaudiAlgcLcLPrint(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::GaudiAlg::Print*)
   {
      ::GaudiAlg::Print *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::GaudiAlg::Print));
      static ::ROOT::TGenericClassInfo 
         instance("GaudiAlg::Print", "GaudiAlg/Print.h", 52,
                  typeid(::GaudiAlg::Print), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &GaudiAlgcLcLPrint_Dictionary, isa_proxy, 4,
                  sizeof(::GaudiAlg::Print) );
      instance.SetNew(&new_GaudiAlgcLcLPrint);
      instance.SetNewArray(&newArray_GaudiAlgcLcLPrint);
      instance.SetDelete(&delete_GaudiAlgcLcLPrint);
      instance.SetDeleteArray(&deleteArray_GaudiAlgcLcLPrint);
      instance.SetDestructor(&destruct_GaudiAlgcLcLPrint);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::GaudiAlg::Print*)
   {
      return GenerateInitInstanceLocal((::GaudiAlg::Print*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::GaudiAlg::Print*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *GaudiAlgcLcLPrint_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::GaudiAlg::Print*)0x0)->GetClass();
      GaudiAlgcLcLPrint_TClassManip(theClass);
   return theClass;
   }

   static void GaudiAlgcLcLPrint_TClassManip(TClass* ){
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *GaudiAlgcLcLPrint1D_Dictionary();
   static void GaudiAlgcLcLPrint1D_TClassManip(TClass*);
   static void *new_GaudiAlgcLcLPrint1D(void *p = 0);
   static void *newArray_GaudiAlgcLcLPrint1D(Long_t size, void *p);
   static void delete_GaudiAlgcLcLPrint1D(void *p);
   static void deleteArray_GaudiAlgcLcLPrint1D(void *p);
   static void destruct_GaudiAlgcLcLPrint1D(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::GaudiAlg::Print1D*)
   {
      ::GaudiAlg::Print1D *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::GaudiAlg::Print1D));
      static ::ROOT::TGenericClassInfo 
         instance("GaudiAlg::Print1D", "GaudiAlg/Print.h", 65,
                  typeid(::GaudiAlg::Print1D), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &GaudiAlgcLcLPrint1D_Dictionary, isa_proxy, 4,
                  sizeof(::GaudiAlg::Print1D) );
      instance.SetNew(&new_GaudiAlgcLcLPrint1D);
      instance.SetNewArray(&newArray_GaudiAlgcLcLPrint1D);
      instance.SetDelete(&delete_GaudiAlgcLcLPrint1D);
      instance.SetDeleteArray(&deleteArray_GaudiAlgcLcLPrint1D);
      instance.SetDestructor(&destruct_GaudiAlgcLcLPrint1D);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::GaudiAlg::Print1D*)
   {
      return GenerateInitInstanceLocal((::GaudiAlg::Print1D*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::GaudiAlg::Print1D*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *GaudiAlgcLcLPrint1D_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::GaudiAlg::Print1D*)0x0)->GetClass();
      GaudiAlgcLcLPrint1D_TClassManip(theClass);
   return theClass;
   }

   static void GaudiAlgcLcLPrint1D_TClassManip(TClass* ){
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *GaudiAlgcLcLPrint2D_Dictionary();
   static void GaudiAlgcLcLPrint2D_TClassManip(TClass*);
   static void *new_GaudiAlgcLcLPrint2D(void *p = 0);
   static void *newArray_GaudiAlgcLcLPrint2D(Long_t size, void *p);
   static void delete_GaudiAlgcLcLPrint2D(void *p);
   static void deleteArray_GaudiAlgcLcLPrint2D(void *p);
   static void destruct_GaudiAlgcLcLPrint2D(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::GaudiAlg::Print2D*)
   {
      ::GaudiAlg::Print2D *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::GaudiAlg::Print2D));
      static ::ROOT::TGenericClassInfo 
         instance("GaudiAlg::Print2D", "GaudiAlg/Print.h", 80,
                  typeid(::GaudiAlg::Print2D), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &GaudiAlgcLcLPrint2D_Dictionary, isa_proxy, 4,
                  sizeof(::GaudiAlg::Print2D) );
      instance.SetNew(&new_GaudiAlgcLcLPrint2D);
      instance.SetNewArray(&newArray_GaudiAlgcLcLPrint2D);
      instance.SetDelete(&delete_GaudiAlgcLcLPrint2D);
      instance.SetDeleteArray(&deleteArray_GaudiAlgcLcLPrint2D);
      instance.SetDestructor(&destruct_GaudiAlgcLcLPrint2D);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::GaudiAlg::Print2D*)
   {
      return GenerateInitInstanceLocal((::GaudiAlg::Print2D*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::GaudiAlg::Print2D*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *GaudiAlgcLcLPrint2D_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::GaudiAlg::Print2D*)0x0)->GetClass();
      GaudiAlgcLcLPrint2D_TClassManip(theClass);
   return theClass;
   }

   static void GaudiAlgcLcLPrint2D_TClassManip(TClass* ){
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *GaudiAlgcLcLPrint3D_Dictionary();
   static void GaudiAlgcLcLPrint3D_TClassManip(TClass*);
   static void *new_GaudiAlgcLcLPrint3D(void *p = 0);
   static void *newArray_GaudiAlgcLcLPrint3D(Long_t size, void *p);
   static void delete_GaudiAlgcLcLPrint3D(void *p);
   static void deleteArray_GaudiAlgcLcLPrint3D(void *p);
   static void destruct_GaudiAlgcLcLPrint3D(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::GaudiAlg::Print3D*)
   {
      ::GaudiAlg::Print3D *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::GaudiAlg::Print3D));
      static ::ROOT::TGenericClassInfo 
         instance("GaudiAlg::Print3D", "GaudiAlg/Print.h", 96,
                  typeid(::GaudiAlg::Print3D), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &GaudiAlgcLcLPrint3D_Dictionary, isa_proxy, 4,
                  sizeof(::GaudiAlg::Print3D) );
      instance.SetNew(&new_GaudiAlgcLcLPrint3D);
      instance.SetNewArray(&newArray_GaudiAlgcLcLPrint3D);
      instance.SetDelete(&delete_GaudiAlgcLcLPrint3D);
      instance.SetDeleteArray(&deleteArray_GaudiAlgcLcLPrint3D);
      instance.SetDestructor(&destruct_GaudiAlgcLcLPrint3D);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::GaudiAlg::Print3D*)
   {
      return GenerateInitInstanceLocal((::GaudiAlg::Print3D*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::GaudiAlg::Print3D*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *GaudiAlgcLcLPrint3D_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::GaudiAlg::Print3D*)0x0)->GetClass();
      GaudiAlgcLcLPrint3D_TClassManip(theClass);
   return theClass;
   }

   static void GaudiAlgcLcLPrint3D_TClassManip(TClass* ){
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *GaudiAlgcLcLPrint1DProf_Dictionary();
   static void GaudiAlgcLcLPrint1DProf_TClassManip(TClass*);
   static void *new_GaudiAlgcLcLPrint1DProf(void *p = 0);
   static void *newArray_GaudiAlgcLcLPrint1DProf(Long_t size, void *p);
   static void delete_GaudiAlgcLcLPrint1DProf(void *p);
   static void deleteArray_GaudiAlgcLcLPrint1DProf(void *p);
   static void destruct_GaudiAlgcLcLPrint1DProf(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::GaudiAlg::Print1DProf*)
   {
      ::GaudiAlg::Print1DProf *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::GaudiAlg::Print1DProf));
      static ::ROOT::TGenericClassInfo 
         instance("GaudiAlg::Print1DProf", "GaudiAlg/Print.h", 112,
                  typeid(::GaudiAlg::Print1DProf), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &GaudiAlgcLcLPrint1DProf_Dictionary, isa_proxy, 4,
                  sizeof(::GaudiAlg::Print1DProf) );
      instance.SetNew(&new_GaudiAlgcLcLPrint1DProf);
      instance.SetNewArray(&newArray_GaudiAlgcLcLPrint1DProf);
      instance.SetDelete(&delete_GaudiAlgcLcLPrint1DProf);
      instance.SetDeleteArray(&deleteArray_GaudiAlgcLcLPrint1DProf);
      instance.SetDestructor(&destruct_GaudiAlgcLcLPrint1DProf);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::GaudiAlg::Print1DProf*)
   {
      return GenerateInitInstanceLocal((::GaudiAlg::Print1DProf*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::GaudiAlg::Print1DProf*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *GaudiAlgcLcLPrint1DProf_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::GaudiAlg::Print1DProf*)0x0)->GetClass();
      GaudiAlgcLcLPrint1DProf_TClassManip(theClass);
   return theClass;
   }

   static void GaudiAlgcLcLPrint1DProf_TClassManip(TClass* ){
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *GaudiAlgcLcLPrint2DProf_Dictionary();
   static void GaudiAlgcLcLPrint2DProf_TClassManip(TClass*);
   static void *new_GaudiAlgcLcLPrint2DProf(void *p = 0);
   static void *newArray_GaudiAlgcLcLPrint2DProf(Long_t size, void *p);
   static void delete_GaudiAlgcLcLPrint2DProf(void *p);
   static void deleteArray_GaudiAlgcLcLPrint2DProf(void *p);
   static void destruct_GaudiAlgcLcLPrint2DProf(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::GaudiAlg::Print2DProf*)
   {
      ::GaudiAlg::Print2DProf *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::GaudiAlg::Print2DProf));
      static ::ROOT::TGenericClassInfo 
         instance("GaudiAlg::Print2DProf", "GaudiAlg/Print.h", 128,
                  typeid(::GaudiAlg::Print2DProf), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &GaudiAlgcLcLPrint2DProf_Dictionary, isa_proxy, 4,
                  sizeof(::GaudiAlg::Print2DProf) );
      instance.SetNew(&new_GaudiAlgcLcLPrint2DProf);
      instance.SetNewArray(&newArray_GaudiAlgcLcLPrint2DProf);
      instance.SetDelete(&delete_GaudiAlgcLcLPrint2DProf);
      instance.SetDeleteArray(&deleteArray_GaudiAlgcLcLPrint2DProf);
      instance.SetDestructor(&destruct_GaudiAlgcLcLPrint2DProf);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::GaudiAlg::Print2DProf*)
   {
      return GenerateInitInstanceLocal((::GaudiAlg::Print2DProf*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::GaudiAlg::Print2DProf*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *GaudiAlgcLcLPrint2DProf_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::GaudiAlg::Print2DProf*)0x0)->GetClass();
      GaudiAlgcLcLPrint2DProf_TClassManip(theClass);
   return theClass;
   }

   static void GaudiAlgcLcLPrint2DProf_TClassManip(TClass* ){
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *GaudiAlgcLcLPrintTuple_Dictionary();
   static void GaudiAlgcLcLPrintTuple_TClassManip(TClass*);
   static void *new_GaudiAlgcLcLPrintTuple(void *p = 0);
   static void *newArray_GaudiAlgcLcLPrintTuple(Long_t size, void *p);
   static void delete_GaudiAlgcLcLPrintTuple(void *p);
   static void deleteArray_GaudiAlgcLcLPrintTuple(void *p);
   static void destruct_GaudiAlgcLcLPrintTuple(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::GaudiAlg::PrintTuple*)
   {
      ::GaudiAlg::PrintTuple *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::GaudiAlg::PrintTuple));
      static ::ROOT::TGenericClassInfo 
         instance("GaudiAlg::PrintTuple", "GaudiAlg/Print.h", 145,
                  typeid(::GaudiAlg::PrintTuple), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &GaudiAlgcLcLPrintTuple_Dictionary, isa_proxy, 4,
                  sizeof(::GaudiAlg::PrintTuple) );
      instance.SetNew(&new_GaudiAlgcLcLPrintTuple);
      instance.SetNewArray(&newArray_GaudiAlgcLcLPrintTuple);
      instance.SetDelete(&delete_GaudiAlgcLcLPrintTuple);
      instance.SetDeleteArray(&deleteArray_GaudiAlgcLcLPrintTuple);
      instance.SetDestructor(&destruct_GaudiAlgcLcLPrintTuple);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::GaudiAlg::PrintTuple*)
   {
      return GenerateInitInstanceLocal((::GaudiAlg::PrintTuple*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::GaudiAlg::PrintTuple*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *GaudiAlgcLcLPrintTuple_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::GaudiAlg::PrintTuple*)0x0)->GetClass();
      GaudiAlgcLcLPrintTuple_TClassManip(theClass);
   return theClass;
   }

   static void GaudiAlgcLcLPrintTuple_TClassManip(TClass* ){
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *GaudiAlgcLcLPrintStat_Dictionary();
   static void GaudiAlgcLcLPrintStat_TClassManip(TClass*);
   static void *new_GaudiAlgcLcLPrintStat(void *p = 0);
   static void *newArray_GaudiAlgcLcLPrintStat(Long_t size, void *p);
   static void delete_GaudiAlgcLcLPrintStat(void *p);
   static void deleteArray_GaudiAlgcLcLPrintStat(void *p);
   static void destruct_GaudiAlgcLcLPrintStat(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::GaudiAlg::PrintStat*)
   {
      ::GaudiAlg::PrintStat *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::GaudiAlg::PrintStat));
      static ::ROOT::TGenericClassInfo 
         instance("GaudiAlg::PrintStat", "GaudiAlg/Print.h", 162,
                  typeid(::GaudiAlg::PrintStat), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &GaudiAlgcLcLPrintStat_Dictionary, isa_proxy, 4,
                  sizeof(::GaudiAlg::PrintStat) );
      instance.SetNew(&new_GaudiAlgcLcLPrintStat);
      instance.SetNewArray(&newArray_GaudiAlgcLcLPrintStat);
      instance.SetDelete(&delete_GaudiAlgcLcLPrintStat);
      instance.SetDeleteArray(&deleteArray_GaudiAlgcLcLPrintStat);
      instance.SetDestructor(&destruct_GaudiAlgcLcLPrintStat);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::GaudiAlg::PrintStat*)
   {
      return GenerateInitInstanceLocal((::GaudiAlg::PrintStat*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::GaudiAlg::PrintStat*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *GaudiAlgcLcLPrintStat_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::GaudiAlg::PrintStat*)0x0)->GetClass();
      GaudiAlgcLcLPrintStat_TClassManip(theClass);
   return theClass;
   }

   static void GaudiAlgcLcLPrintStat_TClassManip(TClass* ){
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *IErrorTool_Dictionary();
   static void IErrorTool_TClassManip(TClass*);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::IErrorTool*)
   {
      ::IErrorTool *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::IErrorTool));
      static ::ROOT::TGenericClassInfo 
         instance("IErrorTool", "GaudiAlg/IErrorTool.h", 24,
                  typeid(::IErrorTool), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &IErrorTool_Dictionary, isa_proxy, 4,
                  sizeof(::IErrorTool) );
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::IErrorTool*)
   {
      return GenerateInitInstanceLocal((::IErrorTool*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::IErrorTool*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *IErrorTool_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::IErrorTool*)0x0)->GetClass();
      IErrorTool_TClassManip(theClass);
   return theClass;
   }

   static void IErrorTool_TClassManip(TClass* ){
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *IGenericTool_Dictionary();
   static void IGenericTool_TClassManip(TClass*);
   static void delete_IGenericTool(void *p);
   static void deleteArray_IGenericTool(void *p);
   static void destruct_IGenericTool(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::IGenericTool*)
   {
      ::IGenericTool *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::IGenericTool));
      static ::ROOT::TGenericClassInfo 
         instance("IGenericTool", "GaudiAlg/IGenericTool.h", 13,
                  typeid(::IGenericTool), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &IGenericTool_Dictionary, isa_proxy, 4,
                  sizeof(::IGenericTool) );
      instance.SetDelete(&delete_IGenericTool);
      instance.SetDeleteArray(&deleteArray_IGenericTool);
      instance.SetDestructor(&destruct_IGenericTool);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::IGenericTool*)
   {
      return GenerateInitInstanceLocal((::IGenericTool*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::IGenericTool*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *IGenericTool_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::IGenericTool*)0x0)->GetClass();
      IGenericTool_TClassManip(theClass);
   return theClass;
   }

   static void IGenericTool_TClassManip(TClass* ){
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *IHistoTool_Dictionary();
   static void IHistoTool_TClassManip(TClass*);
   static void delete_IHistoTool(void *p);
   static void deleteArray_IHistoTool(void *p);
   static void destruct_IHistoTool(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::IHistoTool*)
   {
      ::IHistoTool *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::IHistoTool));
      static ::ROOT::TGenericClassInfo 
         instance("IHistoTool", "GaudiAlg/IHistoTool.h", 31,
                  typeid(::IHistoTool), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &IHistoTool_Dictionary, isa_proxy, 4,
                  sizeof(::IHistoTool) );
      instance.SetDelete(&delete_IHistoTool);
      instance.SetDeleteArray(&deleteArray_IHistoTool);
      instance.SetDestructor(&destruct_IHistoTool);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::IHistoTool*)
   {
      return GenerateInitInstanceLocal((::IHistoTool*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::IHistoTool*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *IHistoTool_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::IHistoTool*)0x0)->GetClass();
      IHistoTool_TClassManip(theClass);
   return theClass;
   }

   static void IHistoTool_TClassManip(TClass* ){
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *ISequencerTimerTool_Dictionary();
   static void ISequencerTimerTool_TClassManip(TClass*);
   static void delete_ISequencerTimerTool(void *p);
   static void deleteArray_ISequencerTimerTool(void *p);
   static void destruct_ISequencerTimerTool(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::ISequencerTimerTool*)
   {
      ::ISequencerTimerTool *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::ISequencerTimerTool));
      static ::ROOT::TGenericClassInfo 
         instance("ISequencerTimerTool", "GaudiAlg/ISequencerTimerTool.h", 14,
                  typeid(::ISequencerTimerTool), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &ISequencerTimerTool_Dictionary, isa_proxy, 4,
                  sizeof(::ISequencerTimerTool) );
      instance.SetDelete(&delete_ISequencerTimerTool);
      instance.SetDeleteArray(&deleteArray_ISequencerTimerTool);
      instance.SetDestructor(&destruct_ISequencerTimerTool);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::ISequencerTimerTool*)
   {
      return GenerateInitInstanceLocal((::ISequencerTimerTool*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::ISequencerTimerTool*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *ISequencerTimerTool_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::ISequencerTimerTool*)0x0)->GetClass();
      ISequencerTimerTool_TClassManip(theClass);
   return theClass;
   }

   static void ISequencerTimerTool_TClassManip(TClass* ){
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *GaudicLcLUtilscLcLAida2ROOT_Dictionary();
   static void GaudicLcLUtilscLcLAida2ROOT_TClassManip(TClass*);
   static void *new_GaudicLcLUtilscLcLAida2ROOT(void *p = 0);
   static void *newArray_GaudicLcLUtilscLcLAida2ROOT(Long_t size, void *p);
   static void delete_GaudicLcLUtilscLcLAida2ROOT(void *p);
   static void deleteArray_GaudicLcLUtilscLcLAida2ROOT(void *p);
   static void destruct_GaudicLcLUtilscLcLAida2ROOT(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::Gaudi::Utils::Aida2ROOT*)
   {
      ::Gaudi::Utils::Aida2ROOT *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::Gaudi::Utils::Aida2ROOT));
      static ::ROOT::TGenericClassInfo 
         instance("Gaudi::Utils::Aida2ROOT", "GaudiUtils/Aida2ROOT.h", 60,
                  typeid(::Gaudi::Utils::Aida2ROOT), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &GaudicLcLUtilscLcLAida2ROOT_Dictionary, isa_proxy, 4,
                  sizeof(::Gaudi::Utils::Aida2ROOT) );
      instance.SetNew(&new_GaudicLcLUtilscLcLAida2ROOT);
      instance.SetNewArray(&newArray_GaudicLcLUtilscLcLAida2ROOT);
      instance.SetDelete(&delete_GaudicLcLUtilscLcLAida2ROOT);
      instance.SetDeleteArray(&deleteArray_GaudicLcLUtilscLcLAida2ROOT);
      instance.SetDestructor(&destruct_GaudicLcLUtilscLcLAida2ROOT);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::Gaudi::Utils::Aida2ROOT*)
   {
      return GenerateInitInstanceLocal((::Gaudi::Utils::Aida2ROOT*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::Gaudi::Utils::Aida2ROOT*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *GaudicLcLUtilscLcLAida2ROOT_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::Gaudi::Utils::Aida2ROOT*)0x0)->GetClass();
      GaudicLcLUtilscLcLAida2ROOT_TClassManip(theClass);
   return theClass;
   }

   static void GaudicLcLUtilscLcLAida2ROOT_TClassManip(TClass* ){
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *GaudicLcLUtilscLcLHistoStats_Dictionary();
   static void GaudicLcLUtilscLcLHistoStats_TClassManip(TClass*);
   static void *new_GaudicLcLUtilscLcLHistoStats(void *p = 0);
   static void *newArray_GaudicLcLUtilscLcLHistoStats(Long_t size, void *p);
   static void delete_GaudicLcLUtilscLcLHistoStats(void *p);
   static void deleteArray_GaudicLcLUtilscLcLHistoStats(void *p);
   static void destruct_GaudicLcLUtilscLcLHistoStats(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::Gaudi::Utils::HistoStats*)
   {
      ::Gaudi::Utils::HistoStats *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::Gaudi::Utils::HistoStats));
      static ::ROOT::TGenericClassInfo 
         instance("Gaudi::Utils::HistoStats", "GaudiUtils/HistoStats.h", 32,
                  typeid(::Gaudi::Utils::HistoStats), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &GaudicLcLUtilscLcLHistoStats_Dictionary, isa_proxy, 4,
                  sizeof(::Gaudi::Utils::HistoStats) );
      instance.SetNew(&new_GaudicLcLUtilscLcLHistoStats);
      instance.SetNewArray(&newArray_GaudicLcLUtilscLcLHistoStats);
      instance.SetDelete(&delete_GaudicLcLUtilscLcLHistoStats);
      instance.SetDeleteArray(&deleteArray_GaudicLcLUtilscLcLHistoStats);
      instance.SetDestructor(&destruct_GaudicLcLUtilscLcLHistoStats);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::Gaudi::Utils::HistoStats*)
   {
      return GenerateInitInstanceLocal((::Gaudi::Utils::HistoStats*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::Gaudi::Utils::HistoStats*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *GaudicLcLUtilscLcLHistoStats_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::Gaudi::Utils::HistoStats*)0x0)->GetClass();
      GaudicLcLUtilscLcLHistoStats_TClassManip(theClass);
   return theClass;
   }

   static void GaudicLcLUtilscLcLHistoStats_TClassManip(TClass* ){
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *GaudicLcLUtilscLcLHistoscLcLHistoStrings_Dictionary();
   static void GaudicLcLUtilscLcLHistoscLcLHistoStrings_TClassManip(TClass*);
   static void *new_GaudicLcLUtilscLcLHistoscLcLHistoStrings(void *p = 0);
   static void *newArray_GaudicLcLUtilscLcLHistoscLcLHistoStrings(Long_t size, void *p);
   static void delete_GaudicLcLUtilscLcLHistoscLcLHistoStrings(void *p);
   static void deleteArray_GaudicLcLUtilscLcLHistoscLcLHistoStrings(void *p);
   static void destruct_GaudicLcLUtilscLcLHistoscLcLHistoStrings(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::Gaudi::Utils::Histos::HistoStrings*)
   {
      ::Gaudi::Utils::Histos::HistoStrings *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::Gaudi::Utils::Histos::HistoStrings));
      static ::ROOT::TGenericClassInfo 
         instance("Gaudi::Utils::Histos::HistoStrings", "GaudiUtils/HistoStrings.h", 52,
                  typeid(::Gaudi::Utils::Histos::HistoStrings), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &GaudicLcLUtilscLcLHistoscLcLHistoStrings_Dictionary, isa_proxy, 4,
                  sizeof(::Gaudi::Utils::Histos::HistoStrings) );
      instance.SetNew(&new_GaudicLcLUtilscLcLHistoscLcLHistoStrings);
      instance.SetNewArray(&newArray_GaudicLcLUtilscLcLHistoscLcLHistoStrings);
      instance.SetDelete(&delete_GaudicLcLUtilscLcLHistoscLcLHistoStrings);
      instance.SetDeleteArray(&deleteArray_GaudicLcLUtilscLcLHistoscLcLHistoStrings);
      instance.SetDestructor(&destruct_GaudicLcLUtilscLcLHistoscLcLHistoStrings);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::Gaudi::Utils::Histos::HistoStrings*)
   {
      return GenerateInitInstanceLocal((::Gaudi::Utils::Histos::HistoStrings*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::Gaudi::Utils::Histos::HistoStrings*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *GaudicLcLUtilscLcLHistoscLcLHistoStrings_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::Gaudi::Utils::Histos::HistoStrings*)0x0)->GetClass();
      GaudicLcLUtilscLcLHistoscLcLHistoStrings_TClassManip(theClass);
   return theClass;
   }

   static void GaudicLcLUtilscLcLHistoscLcLHistoStrings_TClassManip(TClass* ){
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *GaudicLcLIFileCatalog_Dictionary();
   static void GaudicLcLIFileCatalog_TClassManip(TClass*);
   static void delete_GaudicLcLIFileCatalog(void *p);
   static void deleteArray_GaudicLcLIFileCatalog(void *p);
   static void destruct_GaudicLcLIFileCatalog(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::Gaudi::IFileCatalog*)
   {
      ::Gaudi::IFileCatalog *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::Gaudi::IFileCatalog));
      static ::ROOT::TGenericClassInfo 
         instance("Gaudi::IFileCatalog", "GaudiUtils/IFileCatalog.h", 27,
                  typeid(::Gaudi::IFileCatalog), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &GaudicLcLIFileCatalog_Dictionary, isa_proxy, 4,
                  sizeof(::Gaudi::IFileCatalog) );
      instance.SetDelete(&delete_GaudicLcLIFileCatalog);
      instance.SetDeleteArray(&deleteArray_GaudicLcLIFileCatalog);
      instance.SetDestructor(&destruct_GaudicLcLIFileCatalog);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::Gaudi::IFileCatalog*)
   {
      return GenerateInitInstanceLocal((::Gaudi::IFileCatalog*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::Gaudi::IFileCatalog*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *GaudicLcLIFileCatalog_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::Gaudi::IFileCatalog*)0x0)->GetClass();
      GaudicLcLIFileCatalog_TClassManip(theClass);
   return theClass;
   }

   static void GaudicLcLIFileCatalog_TClassManip(TClass* ){
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *GaudicLcLIFileCatalogMgr_Dictionary();
   static void GaudicLcLIFileCatalogMgr_TClassManip(TClass*);
   static void delete_GaudicLcLIFileCatalogMgr(void *p);
   static void deleteArray_GaudicLcLIFileCatalogMgr(void *p);
   static void destruct_GaudicLcLIFileCatalogMgr(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::Gaudi::IFileCatalogMgr*)
   {
      ::Gaudi::IFileCatalogMgr *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::Gaudi::IFileCatalogMgr));
      static ::ROOT::TGenericClassInfo 
         instance("Gaudi::IFileCatalogMgr", "GaudiUtils/IFileCatalogMgr.h", 27,
                  typeid(::Gaudi::IFileCatalogMgr), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &GaudicLcLIFileCatalogMgr_Dictionary, isa_proxy, 4,
                  sizeof(::Gaudi::IFileCatalogMgr) );
      instance.SetDelete(&delete_GaudicLcLIFileCatalogMgr);
      instance.SetDeleteArray(&deleteArray_GaudicLcLIFileCatalogMgr);
      instance.SetDestructor(&destruct_GaudicLcLIFileCatalogMgr);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::Gaudi::IFileCatalogMgr*)
   {
      return GenerateInitInstanceLocal((::Gaudi::IFileCatalogMgr*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::Gaudi::IFileCatalogMgr*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *GaudicLcLIFileCatalogMgr_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::Gaudi::IFileCatalogMgr*)0x0)->GetClass();
      GaudicLcLIFileCatalogMgr_TClassManip(theClass);
   return theClass;
   }

   static void GaudicLcLIFileCatalogMgr_TClassManip(TClass* ){
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *GaudicLcLIDataConnection_Dictionary();
   static void GaudicLcLIDataConnection_TClassManip(TClass*);
   static void delete_GaudicLcLIDataConnection(void *p);
   static void deleteArray_GaudicLcLIDataConnection(void *p);
   static void destruct_GaudicLcLIDataConnection(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::Gaudi::IDataConnection*)
   {
      ::Gaudi::IDataConnection *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::Gaudi::IDataConnection));
      static ::ROOT::TGenericClassInfo 
         instance("Gaudi::IDataConnection", "GaudiUtils/IIODataManager.h", 25,
                  typeid(::Gaudi::IDataConnection), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &GaudicLcLIDataConnection_Dictionary, isa_proxy, 4,
                  sizeof(::Gaudi::IDataConnection) );
      instance.SetDelete(&delete_GaudicLcLIDataConnection);
      instance.SetDeleteArray(&deleteArray_GaudicLcLIDataConnection);
      instance.SetDestructor(&destruct_GaudicLcLIDataConnection);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::Gaudi::IDataConnection*)
   {
      return GenerateInitInstanceLocal((::Gaudi::IDataConnection*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::Gaudi::IDataConnection*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *GaudicLcLIDataConnection_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::Gaudi::IDataConnection*)0x0)->GetClass();
      GaudicLcLIDataConnection_TClassManip(theClass);
   return theClass;
   }

   static void GaudicLcLIDataConnection_TClassManip(TClass* ){
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *GaudicLcLIIODataManager_Dictionary();
   static void GaudicLcLIIODataManager_TClassManip(TClass*);
   static void delete_GaudicLcLIIODataManager(void *p);
   static void deleteArray_GaudicLcLIIODataManager(void *p);
   static void destruct_GaudicLcLIIODataManager(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::Gaudi::IIODataManager*)
   {
      ::Gaudi::IIODataManager *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::Gaudi::IIODataManager));
      static ::ROOT::TGenericClassInfo 
         instance("Gaudi::IIODataManager", "GaudiUtils/IIODataManager.h", 90,
                  typeid(::Gaudi::IIODataManager), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &GaudicLcLIIODataManager_Dictionary, isa_proxy, 4,
                  sizeof(::Gaudi::IIODataManager) );
      instance.SetDelete(&delete_GaudicLcLIIODataManager);
      instance.SetDeleteArray(&deleteArray_GaudicLcLIIODataManager);
      instance.SetDestructor(&destruct_GaudicLcLIIODataManager);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::Gaudi::IIODataManager*)
   {
      return GenerateInitInstanceLocal((::Gaudi::IIODataManager*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::Gaudi::IIODataManager*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *GaudicLcLIIODataManager_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::Gaudi::IIODataManager*)0x0)->GetClass();
      GaudicLcLIIODataManager_TClassManip(theClass);
   return theClass;
   }

   static void GaudicLcLIIODataManager_TClassManip(TClass* ){
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *__gnu_cxxcLcLdummy_Dictionary();
   static void __gnu_cxxcLcLdummy_TClassManip(TClass*);
   static void *new___gnu_cxxcLcLdummy(void *p = 0);
   static void *newArray___gnu_cxxcLcLdummy(Long_t size, void *p);
   static void delete___gnu_cxxcLcLdummy(void *p);
   static void deleteArray___gnu_cxxcLcLdummy(void *p);
   static void destruct___gnu_cxxcLcLdummy(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::__gnu_cxx::dummy*)
   {
      ::__gnu_cxx::dummy *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::__gnu_cxx::dummy));
      static ::ROOT::TGenericClassInfo 
         instance("__gnu_cxx::dummy", "", 270,
                  typeid(::__gnu_cxx::dummy), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &__gnu_cxxcLcLdummy_Dictionary, isa_proxy, 4,
                  sizeof(::__gnu_cxx::dummy) );
      instance.SetNew(&new___gnu_cxxcLcLdummy);
      instance.SetNewArray(&newArray___gnu_cxxcLcLdummy);
      instance.SetDelete(&delete___gnu_cxxcLcLdummy);
      instance.SetDeleteArray(&deleteArray___gnu_cxxcLcLdummy);
      instance.SetDestructor(&destruct___gnu_cxxcLcLdummy);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::__gnu_cxx::dummy*)
   {
      return GenerateInitInstanceLocal((::__gnu_cxx::dummy*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::__gnu_cxx::dummy*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *__gnu_cxxcLcLdummy_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::__gnu_cxx::dummy*)0x0)->GetClass();
      __gnu_cxxcLcLdummy_TClassManip(theClass);
   return theClass;
   }

   static void __gnu_cxxcLcLdummy_TClassManip(TClass* ){
   }

} // end of namespace ROOT

namespace ROOT {
   // Wrappers around operator new
   static void *new_allocatorlEIServicemUgR(void *p) {
      return  p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) allocator<IService*> : new allocator<IService*>;
   }
   static void *newArray_allocatorlEIServicemUgR(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) allocator<IService*>[nElements] : new allocator<IService*>[nElements];
   }
   // Wrapper around operator delete
   static void delete_allocatorlEIServicemUgR(void *p) {
      delete ((allocator<IService*>*)p);
   }
   static void deleteArray_allocatorlEIServicemUgR(void *p) {
      delete [] ((allocator<IService*>*)p);
   }
   static void destruct_allocatorlEIServicemUgR(void *p) {
      typedef allocator<IService*> current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class allocator<IService*>

namespace ROOT {
   // Wrappers around operator new
   static void *new_allocatorlEIAlgorithmmUgR(void *p) {
      return  p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) allocator<IAlgorithm*> : new allocator<IAlgorithm*>;
   }
   static void *newArray_allocatorlEIAlgorithmmUgR(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) allocator<IAlgorithm*>[nElements] : new allocator<IAlgorithm*>[nElements];
   }
   // Wrapper around operator delete
   static void delete_allocatorlEIAlgorithmmUgR(void *p) {
      delete ((allocator<IAlgorithm*>*)p);
   }
   static void deleteArray_allocatorlEIAlgorithmmUgR(void *p) {
      delete [] ((allocator<IAlgorithm*>*)p);
   }
   static void destruct_allocatorlEIAlgorithmmUgR(void *p) {
      typedef allocator<IAlgorithm*> current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class allocator<IAlgorithm*>

namespace ROOT {
   // Wrappers around operator new
   static void *new_allocatorlEIRegistrymUgR(void *p) {
      return  p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) allocator<IRegistry*> : new allocator<IRegistry*>;
   }
   static void *newArray_allocatorlEIRegistrymUgR(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) allocator<IRegistry*>[nElements] : new allocator<IRegistry*>[nElements];
   }
   // Wrapper around operator delete
   static void delete_allocatorlEIRegistrymUgR(void *p) {
      delete ((allocator<IRegistry*>*)p);
   }
   static void deleteArray_allocatorlEIRegistrymUgR(void *p) {
      delete [] ((allocator<IRegistry*>*)p);
   }
   static void destruct_allocatorlEIRegistrymUgR(void *p) {
      typedef allocator<IRegistry*> current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class allocator<IRegistry*>

namespace ROOT {
   // Wrapper around operator delete
   static void delete_basic_ostreamlEcharcOchar_traitslEchargRsPgR(void *p) {
      delete ((::basic_ostream<char,char_traits<char> >*)p);
   }
   static void deleteArray_basic_ostreamlEcharcOchar_traitslEchargRsPgR(void *p) {
      delete [] ((::basic_ostream<char,char_traits<char> >*)p);
   }
   static void destruct_basic_ostreamlEcharcOchar_traitslEchargRsPgR(void *p) {
      typedef ::basic_ostream<char,char_traits<char> > current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::basic_ostream<char,char_traits<char> >

namespace ROOT {
   // Wrappers around operator new
   static void *new__Bit_reference(void *p) {
      return  p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::_Bit_reference : new ::_Bit_reference;
   }
   static void *newArray__Bit_reference(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::_Bit_reference[nElements] : new ::_Bit_reference[nElements];
   }
   // Wrapper around operator delete
   static void delete__Bit_reference(void *p) {
      delete ((::_Bit_reference*)p);
   }
   static void deleteArray__Bit_reference(void *p) {
      delete [] ((::_Bit_reference*)p);
   }
   static void destruct__Bit_reference(void *p) {
      typedef ::_Bit_reference current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::_Bit_reference

namespace ROOT {
   // Wrappers around operator new
   static void *new_basic_stringbuflEcharcOchar_traitslEchargRcOallocatorlEchargRsPgR(void *p) {
      return  p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::basic_stringbuf<char,char_traits<char>,allocator<char> > : new ::basic_stringbuf<char,char_traits<char>,allocator<char> >;
   }
   static void *newArray_basic_stringbuflEcharcOchar_traitslEchargRcOallocatorlEchargRsPgR(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::basic_stringbuf<char,char_traits<char>,allocator<char> >[nElements] : new ::basic_stringbuf<char,char_traits<char>,allocator<char> >[nElements];
   }
   // Wrapper around operator delete
   static void delete_basic_stringbuflEcharcOchar_traitslEchargRcOallocatorlEchargRsPgR(void *p) {
      delete ((::basic_stringbuf<char,char_traits<char>,allocator<char> >*)p);
   }
   static void deleteArray_basic_stringbuflEcharcOchar_traitslEchargRcOallocatorlEchargRsPgR(void *p) {
      delete [] ((::basic_stringbuf<char,char_traits<char>,allocator<char> >*)p);
   }
   static void destruct_basic_stringbuflEcharcOchar_traitslEchargRcOallocatorlEchargRsPgR(void *p) {
      typedef ::basic_stringbuf<char,char_traits<char>,allocator<char> > current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::basic_stringbuf<char,char_traits<char>,allocator<char> >

namespace ROOT {
   // Wrappers around operator new
   static void *new_GaudicLcLUtilscLcLMapBase(void *p) {
      return  p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::Gaudi::Utils::MapBase : new ::Gaudi::Utils::MapBase;
   }
   static void *newArray_GaudicLcLUtilscLcLMapBase(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::Gaudi::Utils::MapBase[nElements] : new ::Gaudi::Utils::MapBase[nElements];
   }
   // Wrapper around operator delete
   static void delete_GaudicLcLUtilscLcLMapBase(void *p) {
      delete ((::Gaudi::Utils::MapBase*)p);
   }
   static void deleteArray_GaudicLcLUtilscLcLMapBase(void *p) {
      delete [] ((::Gaudi::Utils::MapBase*)p);
   }
   static void destruct_GaudicLcLUtilscLcLMapBase(void *p) {
      typedef ::Gaudi::Utils::MapBase current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::Gaudi::Utils::MapBase

namespace ROOT {
   // Wrappers around operator new
   static void *new_GaudicLcLStringKey(void *p) {
      return  p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::Gaudi::StringKey : new ::Gaudi::StringKey;
   }
   static void *newArray_GaudicLcLStringKey(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::Gaudi::StringKey[nElements] : new ::Gaudi::StringKey[nElements];
   }
   // Wrapper around operator delete
   static void delete_GaudicLcLStringKey(void *p) {
      delete ((::Gaudi::StringKey*)p);
   }
   static void deleteArray_GaudicLcLStringKey(void *p) {
      delete [] ((::Gaudi::StringKey*)p);
   }
   static void destruct_GaudicLcLStringKey(void *p) {
      typedef ::Gaudi::StringKey current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::Gaudi::StringKey

namespace ROOT {
   // Wrappers around operator new
   static void *new_StatEntity(void *p) {
      return  p ? new(p) ::StatEntity : new ::StatEntity;
   }
   static void *newArray_StatEntity(Long_t nElements, void *p) {
      return p ? new(p) ::StatEntity[nElements] : new ::StatEntity[nElements];
   }
   // Wrapper around operator delete
   static void delete_StatEntity(void *p) {
      delete ((::StatEntity*)p);
   }
   static void deleteArray_StatEntity(void *p) {
      delete [] ((::StatEntity*)p);
   }
   static void destruct_StatEntity(void *p) {
      typedef ::StatEntity current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::StatEntity

namespace ROOT {
   // Wrappers around operator new
   static void *new_ChronoEntity(void *p) {
      return  p ? new(p) ::ChronoEntity : new ::ChronoEntity;
   }
   static void *newArray_ChronoEntity(Long_t nElements, void *p) {
      return p ? new(p) ::ChronoEntity[nElements] : new ::ChronoEntity[nElements];
   }
   // Wrapper around operator delete
   static void delete_ChronoEntity(void *p) {
      delete ((::ChronoEntity*)p);
   }
   static void deleteArray_ChronoEntity(void *p) {
      delete [] ((::ChronoEntity*)p);
   }
   static void destruct_ChronoEntity(void *p) {
      typedef ::ChronoEntity current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::ChronoEntity

namespace ROOT {
   // Wrappers around operator new
   static void *new_Chrono(void *p) {
      return  p ? new(p) ::Chrono : new ::Chrono;
   }
   static void *newArray_Chrono(Long_t nElements, void *p) {
      return p ? new(p) ::Chrono[nElements] : new ::Chrono[nElements];
   }
   // Wrapper around operator delete
   static void delete_Chrono(void *p) {
      delete ((::Chrono*)p);
   }
   static void deleteArray_Chrono(void *p) {
      delete [] ((::Chrono*)p);
   }
   static void destruct_Chrono(void *p) {
      typedef ::Chrono current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::Chrono

namespace ROOT {
   // Wrappers around operator new
   static void *new_ParticleProperty(void *p) {
      return  p ? new(p) ::ParticleProperty : new ::ParticleProperty;
   }
   static void *newArray_ParticleProperty(Long_t nElements, void *p) {
      return p ? new(p) ::ParticleProperty[nElements] : new ::ParticleProperty[nElements];
   }
   // Wrapper around operator delete
   static void delete_ParticleProperty(void *p) {
      delete ((::ParticleProperty*)p);
   }
   static void deleteArray_ParticleProperty(void *p) {
      delete [] ((::ParticleProperty*)p);
   }
   static void destruct_ParticleProperty(void *p) {
      typedef ::ParticleProperty current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::ParticleProperty

namespace ROOT {
   // Wrappers around operator new
   static void *new_GaudicLcLRangeBase_(void *p) {
      return  p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::Gaudi::RangeBase_ : new ::Gaudi::RangeBase_;
   }
   static void *newArray_GaudicLcLRangeBase_(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::Gaudi::RangeBase_[nElements] : new ::Gaudi::RangeBase_[nElements];
   }
   // Wrapper around operator delete
   static void delete_GaudicLcLRangeBase_(void *p) {
      delete ((::Gaudi::RangeBase_*)p);
   }
   static void deleteArray_GaudicLcLRangeBase_(void *p) {
      delete [] ((::Gaudi::RangeBase_*)p);
   }
   static void destruct_GaudicLcLRangeBase_(void *p) {
      typedef ::Gaudi::RangeBase_ current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::Gaudi::RangeBase_

namespace ROOT {
   // Wrappers around operator new
   static void *new_Stat(void *p) {
      return  p ? new(p) ::Stat : new ::Stat;
   }
   static void *newArray_Stat(Long_t nElements, void *p) {
      return p ? new(p) ::Stat[nElements] : new ::Stat[nElements];
   }
   // Wrapper around operator delete
   static void delete_Stat(void *p) {
      delete ((::Stat*)p);
   }
   static void deleteArray_Stat(void *p) {
      delete [] ((::Stat*)p);
   }
   static void destruct_Stat(void *p) {
      typedef ::Stat current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::Stat

namespace ROOT {
   // Wrapper around operator delete
   static void delete_AIDAcLcLIAxis(void *p) {
      delete ((::AIDA::IAxis*)p);
   }
   static void deleteArray_AIDAcLcLIAxis(void *p) {
      delete [] ((::AIDA::IAxis*)p);
   }
   static void destruct_AIDAcLcLIAxis(void *p) {
      typedef ::AIDA::IAxis current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::AIDA::IAxis

namespace ROOT {
   // Wrapper around operator delete
   static void delete_AIDAcLcLIBaseHistogram(void *p) {
      delete ((::AIDA::IBaseHistogram*)p);
   }
   static void deleteArray_AIDAcLcLIBaseHistogram(void *p) {
      delete [] ((::AIDA::IBaseHistogram*)p);
   }
   static void destruct_AIDAcLcLIBaseHistogram(void *p) {
      typedef ::AIDA::IBaseHistogram current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::AIDA::IBaseHistogram

namespace ROOT {
   // Wrapper around operator delete
   static void delete_AIDAcLcLIHistogram(void *p) {
      delete ((::AIDA::IHistogram*)p);
   }
   static void deleteArray_AIDAcLcLIHistogram(void *p) {
      delete [] ((::AIDA::IHistogram*)p);
   }
   static void destruct_AIDAcLcLIHistogram(void *p) {
      typedef ::AIDA::IHistogram current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::AIDA::IHistogram

namespace ROOT {
   // Wrapper around operator delete
   static void delete_AIDAcLcLIHistogram1D(void *p) {
      delete ((::AIDA::IHistogram1D*)p);
   }
   static void deleteArray_AIDAcLcLIHistogram1D(void *p) {
      delete [] ((::AIDA::IHistogram1D*)p);
   }
   static void destruct_AIDAcLcLIHistogram1D(void *p) {
      typedef ::AIDA::IHistogram1D current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::AIDA::IHistogram1D

namespace ROOT {
   // Wrapper around operator delete
   static void delete_AIDAcLcLIHistogram2D(void *p) {
      delete ((::AIDA::IHistogram2D*)p);
   }
   static void deleteArray_AIDAcLcLIHistogram2D(void *p) {
      delete [] ((::AIDA::IHistogram2D*)p);
   }
   static void destruct_AIDAcLcLIHistogram2D(void *p) {
      typedef ::AIDA::IHistogram2D current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::AIDA::IHistogram2D

namespace ROOT {
   // Wrapper around operator delete
   static void delete_AIDAcLcLIHistogram3D(void *p) {
      delete ((::AIDA::IHistogram3D*)p);
   }
   static void deleteArray_AIDAcLcLIHistogram3D(void *p) {
      delete [] ((::AIDA::IHistogram3D*)p);
   }
   static void destruct_AIDAcLcLIHistogram3D(void *p) {
      typedef ::AIDA::IHistogram3D current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::AIDA::IHistogram3D

namespace ROOT {
   // Wrapper around operator delete
   static void delete_AIDAcLcLIProfile(void *p) {
      delete ((::AIDA::IProfile*)p);
   }
   static void deleteArray_AIDAcLcLIProfile(void *p) {
      delete [] ((::AIDA::IProfile*)p);
   }
   static void destruct_AIDAcLcLIProfile(void *p) {
      typedef ::AIDA::IProfile current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::AIDA::IProfile

namespace ROOT {
   // Wrapper around operator delete
   static void delete_AIDAcLcLIProfile1D(void *p) {
      delete ((::AIDA::IProfile1D*)p);
   }
   static void deleteArray_AIDAcLcLIProfile1D(void *p) {
      delete [] ((::AIDA::IProfile1D*)p);
   }
   static void destruct_AIDAcLcLIProfile1D(void *p) {
      typedef ::AIDA::IProfile1D current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::AIDA::IProfile1D

namespace ROOT {
   // Wrapper around operator delete
   static void delete_AIDAcLcLIProfile2D(void *p) {
      delete ((::AIDA::IProfile2D*)p);
   }
   static void deleteArray_AIDAcLcLIProfile2D(void *p) {
      delete [] ((::AIDA::IProfile2D*)p);
   }
   static void destruct_AIDAcLcLIProfile2D(void *p) {
      typedef ::AIDA::IProfile2D current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::AIDA::IProfile2D

namespace ROOT {
   // Wrappers around operator new
   static void *new_GaudiPythoncLcLHelper(void *p) {
      return  p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::GaudiPython::Helper : new ::GaudiPython::Helper;
   }
   static void *newArray_GaudiPythoncLcLHelper(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::GaudiPython::Helper[nElements] : new ::GaudiPython::Helper[nElements];
   }
   // Wrapper around operator delete
   static void delete_GaudiPythoncLcLHelper(void *p) {
      delete ((::GaudiPython::Helper*)p);
   }
   static void deleteArray_GaudiPythoncLcLHelper(void *p) {
      delete [] ((::GaudiPython::Helper*)p);
   }
   static void destruct_GaudiPythoncLcLHelper(void *p) {
      typedef ::GaudiPython::Helper current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::GaudiPython::Helper

namespace ROOT {
   // Wrapper around operator delete
   static void delete_GaudiCommonlEAlgorithmgR(void *p) {
      delete ((::GaudiCommon<Algorithm>*)p);
   }
   static void deleteArray_GaudiCommonlEAlgorithmgR(void *p) {
      delete [] ((::GaudiCommon<Algorithm>*)p);
   }
   static void destruct_GaudiCommonlEAlgorithmgR(void *p) {
      typedef ::GaudiCommon<Algorithm> current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::GaudiCommon<Algorithm>

namespace ROOT {
   // Wrapper around operator delete
   static void delete_GaudiCommonlEAlgToolgR(void *p) {
      delete ((::GaudiCommon<AlgTool>*)p);
   }
   static void deleteArray_GaudiCommonlEAlgToolgR(void *p) {
      delete [] ((::GaudiCommon<AlgTool>*)p);
   }
   static void destruct_GaudiCommonlEAlgToolgR(void *p) {
      typedef ::GaudiCommon<AlgTool> current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::GaudiCommon<AlgTool>

namespace ROOT {
   // Wrapper around operator delete
   static void delete_GaudiAlgorithm(void *p) {
      delete ((::GaudiAlgorithm*)p);
   }
   static void deleteArray_GaudiAlgorithm(void *p) {
      delete [] ((::GaudiAlgorithm*)p);
   }
   static void destruct_GaudiAlgorithm(void *p) {
      typedef ::GaudiAlgorithm current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::GaudiAlgorithm

namespace ROOT {
   // Wrappers around operator new
   static void *new_GaudiPythoncLcLAlgDecorator(void *p) {
      return  p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::GaudiPython::AlgDecorator : new ::GaudiPython::AlgDecorator;
   }
   static void *newArray_GaudiPythoncLcLAlgDecorator(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::GaudiPython::AlgDecorator[nElements] : new ::GaudiPython::AlgDecorator[nElements];
   }
   // Wrapper around operator delete
   static void delete_GaudiPythoncLcLAlgDecorator(void *p) {
      delete ((::GaudiPython::AlgDecorator*)p);
   }
   static void deleteArray_GaudiPythoncLcLAlgDecorator(void *p) {
      delete [] ((::GaudiPython::AlgDecorator*)p);
   }
   static void destruct_GaudiPythoncLcLAlgDecorator(void *p) {
      typedef ::GaudiPython::AlgDecorator current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::GaudiPython::AlgDecorator

namespace ROOT {
   // Wrapper around operator delete
   static void delete_GaudiPythoncLcLPyAlgorithm(void *p) {
      delete ((::GaudiPython::PyAlgorithm*)p);
   }
   static void deleteArray_GaudiPythoncLcLPyAlgorithm(void *p) {
      delete [] ((::GaudiPython::PyAlgorithm*)p);
   }
   static void destruct_GaudiPythoncLcLPyAlgorithm(void *p) {
      typedef ::GaudiPython::PyAlgorithm current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::GaudiPython::PyAlgorithm

namespace ROOT {
   // Wrapper around operator delete
   static void delete_GaudiPythoncLcLPyAlglEGaudiAlgorithmgR(void *p) {
      delete ((::GaudiPython::PyAlg<GaudiAlgorithm>*)p);
   }
   static void deleteArray_GaudiPythoncLcLPyAlglEGaudiAlgorithmgR(void *p) {
      delete [] ((::GaudiPython::PyAlg<GaudiAlgorithm>*)p);
   }
   static void destruct_GaudiPythoncLcLPyAlglEGaudiAlgorithmgR(void *p) {
      typedef ::GaudiPython::PyAlg<GaudiAlgorithm> current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::GaudiPython::PyAlg<GaudiAlgorithm>

namespace ROOT {
   // Wrapper around operator delete
   static void delete_GaudiPythoncLcLPyAlglEGaudiHistoAlggR(void *p) {
      delete ((::GaudiPython::PyAlg<GaudiHistoAlg>*)p);
   }
   static void deleteArray_GaudiPythoncLcLPyAlglEGaudiHistoAlggR(void *p) {
      delete [] ((::GaudiPython::PyAlg<GaudiHistoAlg>*)p);
   }
   static void destruct_GaudiPythoncLcLPyAlglEGaudiHistoAlggR(void *p) {
      typedef ::GaudiPython::PyAlg<GaudiHistoAlg> current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::GaudiPython::PyAlg<GaudiHistoAlg>

namespace ROOT {
   // Wrapper around operator delete
   static void delete_GaudiPythoncLcLPyAlglEGaudiTupleAlggR(void *p) {
      delete ((::GaudiPython::PyAlg<GaudiTupleAlg>*)p);
   }
   static void deleteArray_GaudiPythoncLcLPyAlglEGaudiTupleAlggR(void *p) {
      delete [] ((::GaudiPython::PyAlg<GaudiTupleAlg>*)p);
   }
   static void destruct_GaudiPythoncLcLPyAlglEGaudiTupleAlggR(void *p) {
      typedef ::GaudiPython::PyAlg<GaudiTupleAlg> current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::GaudiPython::PyAlg<GaudiTupleAlg>

namespace ROOT {
   // Wrapper around operator delete
   static void delete_GaudiPythoncLcLCallbackStreamBuf(void *p) {
      delete ((::GaudiPython::CallbackStreamBuf*)p);
   }
   static void deleteArray_GaudiPythoncLcLCallbackStreamBuf(void *p) {
      delete [] ((::GaudiPython::CallbackStreamBuf*)p);
   }
   static void destruct_GaudiPythoncLcLCallbackStreamBuf(void *p) {
      typedef ::GaudiPython::CallbackStreamBuf current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::GaudiPython::CallbackStreamBuf

namespace ROOT {
   // Wrappers around operator new
   static void *new_GaudicLcLUtilscLcLHistoscLcLTable(void *p) {
      return  p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::Gaudi::Utils::Histos::Table : new ::Gaudi::Utils::Histos::Table;
   }
   static void *newArray_GaudicLcLUtilscLcLHistoscLcLTable(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::Gaudi::Utils::Histos::Table[nElements] : new ::Gaudi::Utils::Histos::Table[nElements];
   }
   // Wrapper around operator delete
   static void delete_GaudicLcLUtilscLcLHistoscLcLTable(void *p) {
      delete ((::Gaudi::Utils::Histos::Table*)p);
   }
   static void deleteArray_GaudicLcLUtilscLcLHistoscLcLTable(void *p) {
      delete [] ((::Gaudi::Utils::Histos::Table*)p);
   }
   static void destruct_GaudicLcLUtilscLcLHistoscLcLTable(void *p) {
      typedef ::Gaudi::Utils::Histos::Table current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::Gaudi::Utils::Histos::Table

namespace ROOT {
   // Wrappers around operator new
   static void *new_GaudiAlgcLcLID(void *p) {
      return  p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::GaudiAlg::ID : new ::GaudiAlg::ID;
   }
   static void *newArray_GaudiAlgcLcLID(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::GaudiAlg::ID[nElements] : new ::GaudiAlg::ID[nElements];
   }
   // Wrapper around operator delete
   static void delete_GaudiAlgcLcLID(void *p) {
      delete ((::GaudiAlg::ID*)p);
   }
   static void deleteArray_GaudiAlgcLcLID(void *p) {
      delete [] ((::GaudiAlg::ID*)p);
   }
   static void destruct_GaudiAlgcLcLID(void *p) {
      typedef ::GaudiAlg::ID current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::GaudiAlg::ID

namespace ROOT {
   // Wrapper around operator delete
   static void delete_GaudiHistoslEGaudiAlgorithmgR(void *p) {
      delete ((::GaudiHistos<GaudiAlgorithm>*)p);
   }
   static void deleteArray_GaudiHistoslEGaudiAlgorithmgR(void *p) {
      delete [] ((::GaudiHistos<GaudiAlgorithm>*)p);
   }
   static void destruct_GaudiHistoslEGaudiAlgorithmgR(void *p) {
      typedef ::GaudiHistos<GaudiAlgorithm> current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::GaudiHistos<GaudiAlgorithm>

namespace ROOT {
   // Wrapper around operator delete
   static void delete_GaudiHistoslEGaudiToolgR(void *p) {
      delete ((::GaudiHistos<GaudiTool>*)p);
   }
   static void deleteArray_GaudiHistoslEGaudiToolgR(void *p) {
      delete [] ((::GaudiHistos<GaudiTool>*)p);
   }
   static void destruct_GaudiHistoslEGaudiToolgR(void *p) {
      typedef ::GaudiHistos<GaudiTool> current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::GaudiHistos<GaudiTool>

namespace ROOT {
   // Wrappers around operator new
   static void *new_GaudiPythoncLcLHistoDecorator(void *p) {
      return  p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::GaudiPython::HistoDecorator : new ::GaudiPython::HistoDecorator;
   }
   static void *newArray_GaudiPythoncLcLHistoDecorator(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::GaudiPython::HistoDecorator[nElements] : new ::GaudiPython::HistoDecorator[nElements];
   }
   // Wrapper around operator delete
   static void delete_GaudiPythoncLcLHistoDecorator(void *p) {
      delete ((::GaudiPython::HistoDecorator*)p);
   }
   static void deleteArray_GaudiPythoncLcLHistoDecorator(void *p) {
      delete [] ((::GaudiPython::HistoDecorator*)p);
   }
   static void destruct_GaudiPythoncLcLHistoDecorator(void *p) {
      typedef ::GaudiPython::HistoDecorator current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::GaudiPython::HistoDecorator

namespace ROOT {
   // Wrappers around operator new
   static void *new_GaudiPythoncLcLPrinterlEContainedObjectgR(void *p) {
      return  p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::GaudiPython::Printer<ContainedObject> : new ::GaudiPython::Printer<ContainedObject>;
   }
   static void *newArray_GaudiPythoncLcLPrinterlEContainedObjectgR(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::GaudiPython::Printer<ContainedObject>[nElements] : new ::GaudiPython::Printer<ContainedObject>[nElements];
   }
   // Wrapper around operator delete
   static void delete_GaudiPythoncLcLPrinterlEContainedObjectgR(void *p) {
      delete ((::GaudiPython::Printer<ContainedObject>*)p);
   }
   static void deleteArray_GaudiPythoncLcLPrinterlEContainedObjectgR(void *p) {
      delete [] ((::GaudiPython::Printer<ContainedObject>*)p);
   }
   static void destruct_GaudiPythoncLcLPrinterlEContainedObjectgR(void *p) {
      typedef ::GaudiPython::Printer<ContainedObject> current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::GaudiPython::Printer<ContainedObject>

namespace ROOT {
   // Wrappers around operator new
   static void *new_GaudiPythoncLcLPrinterlEDataObjectgR(void *p) {
      return  p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::GaudiPython::Printer<DataObject> : new ::GaudiPython::Printer<DataObject>;
   }
   static void *newArray_GaudiPythoncLcLPrinterlEDataObjectgR(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::GaudiPython::Printer<DataObject>[nElements] : new ::GaudiPython::Printer<DataObject>[nElements];
   }
   // Wrapper around operator delete
   static void delete_GaudiPythoncLcLPrinterlEDataObjectgR(void *p) {
      delete ((::GaudiPython::Printer<DataObject>*)p);
   }
   static void deleteArray_GaudiPythoncLcLPrinterlEDataObjectgR(void *p) {
      delete [] ((::GaudiPython::Printer<DataObject>*)p);
   }
   static void destruct_GaudiPythoncLcLPrinterlEDataObjectgR(void *p) {
      typedef ::GaudiPython::Printer<DataObject> current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::GaudiPython::Printer<DataObject>

namespace ROOT {
   // Wrapper around operator delete
   static void delete_TuplescLcLTuple(void *p) {
      delete ((::Tuples::Tuple*)p);
   }
   static void deleteArray_TuplescLcLTuple(void *p) {
      delete [] ((::Tuples::Tuple*)p);
   }
   static void destruct_TuplescLcLTuple(void *p) {
      typedef ::Tuples::Tuple current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::Tuples::Tuple

namespace ROOT {
   // Wrapper around operator delete
   static void delete_GaudiTupleslEGaudiHistoAlggR(void *p) {
      delete ((::GaudiTuples<GaudiHistoAlg>*)p);
   }
   static void deleteArray_GaudiTupleslEGaudiHistoAlggR(void *p) {
      delete [] ((::GaudiTuples<GaudiHistoAlg>*)p);
   }
   static void destruct_GaudiTupleslEGaudiHistoAlggR(void *p) {
      typedef ::GaudiTuples<GaudiHistoAlg> current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::GaudiTuples<GaudiHistoAlg>

namespace ROOT {
   // Wrapper around operator delete
   static void delete_ITupleTool(void *p) {
      delete ((::ITupleTool*)p);
   }
   static void deleteArray_ITupleTool(void *p) {
      delete [] ((::ITupleTool*)p);
   }
   static void destruct_ITupleTool(void *p) {
      typedef ::ITupleTool current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::ITupleTool

namespace ROOT {
   // Wrappers around operator new
   static void *new_GaudiPythoncLcLTupleDecorator(void *p) {
      return  p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::GaudiPython::TupleDecorator : new ::GaudiPython::TupleDecorator;
   }
   static void *newArray_GaudiPythoncLcLTupleDecorator(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::GaudiPython::TupleDecorator[nElements] : new ::GaudiPython::TupleDecorator[nElements];
   }
   // Wrapper around operator delete
   static void delete_GaudiPythoncLcLTupleDecorator(void *p) {
      delete ((::GaudiPython::TupleDecorator*)p);
   }
   static void deleteArray_GaudiPythoncLcLTupleDecorator(void *p) {
      delete [] ((::GaudiPython::TupleDecorator*)p);
   }
   static void destruct_GaudiPythoncLcLTupleDecorator(void *p) {
      typedef ::GaudiPython::TupleDecorator current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::GaudiPython::TupleDecorator

namespace ROOT {
   // Wrappers around operator new
   static void *new_GaudiPythoncLcLTupleAlgDecorator(void *p) {
      return  p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::GaudiPython::TupleAlgDecorator : new ::GaudiPython::TupleAlgDecorator;
   }
   static void *newArray_GaudiPythoncLcLTupleAlgDecorator(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::GaudiPython::TupleAlgDecorator[nElements] : new ::GaudiPython::TupleAlgDecorator[nElements];
   }
   // Wrapper around operator delete
   static void delete_GaudiPythoncLcLTupleAlgDecorator(void *p) {
      delete ((::GaudiPython::TupleAlgDecorator*)p);
   }
   static void deleteArray_GaudiPythoncLcLTupleAlgDecorator(void *p) {
      delete [] ((::GaudiPython::TupleAlgDecorator*)p);
   }
   static void destruct_GaudiPythoncLcLTupleAlgDecorator(void *p) {
      typedef ::GaudiPython::TupleAlgDecorator current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::GaudiPython::TupleAlgDecorator

namespace ROOT {
   // Wrappers around operator new
   static void *new_GaudiPythoncLcLTupleToolDecorator(void *p) {
      return  p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::GaudiPython::TupleToolDecorator : new ::GaudiPython::TupleToolDecorator;
   }
   static void *newArray_GaudiPythoncLcLTupleToolDecorator(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::GaudiPython::TupleToolDecorator[nElements] : new ::GaudiPython::TupleToolDecorator[nElements];
   }
   // Wrapper around operator delete
   static void delete_GaudiPythoncLcLTupleToolDecorator(void *p) {
      delete ((::GaudiPython::TupleToolDecorator*)p);
   }
   static void deleteArray_GaudiPythoncLcLTupleToolDecorator(void *p) {
      delete [] ((::GaudiPython::TupleToolDecorator*)p);
   }
   static void destruct_GaudiPythoncLcLTupleToolDecorator(void *p) {
      typedef ::GaudiPython::TupleToolDecorator current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::GaudiPython::TupleToolDecorator

namespace ROOT {
   // Wrappers around operator new
   static void *new_GaudiAlgcLcLPrint(void *p) {
      return  p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::GaudiAlg::Print : new ::GaudiAlg::Print;
   }
   static void *newArray_GaudiAlgcLcLPrint(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::GaudiAlg::Print[nElements] : new ::GaudiAlg::Print[nElements];
   }
   // Wrapper around operator delete
   static void delete_GaudiAlgcLcLPrint(void *p) {
      delete ((::GaudiAlg::Print*)p);
   }
   static void deleteArray_GaudiAlgcLcLPrint(void *p) {
      delete [] ((::GaudiAlg::Print*)p);
   }
   static void destruct_GaudiAlgcLcLPrint(void *p) {
      typedef ::GaudiAlg::Print current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::GaudiAlg::Print

namespace ROOT {
   // Wrappers around operator new
   static void *new_GaudiAlgcLcLPrint1D(void *p) {
      return  p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::GaudiAlg::Print1D : new ::GaudiAlg::Print1D;
   }
   static void *newArray_GaudiAlgcLcLPrint1D(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::GaudiAlg::Print1D[nElements] : new ::GaudiAlg::Print1D[nElements];
   }
   // Wrapper around operator delete
   static void delete_GaudiAlgcLcLPrint1D(void *p) {
      delete ((::GaudiAlg::Print1D*)p);
   }
   static void deleteArray_GaudiAlgcLcLPrint1D(void *p) {
      delete [] ((::GaudiAlg::Print1D*)p);
   }
   static void destruct_GaudiAlgcLcLPrint1D(void *p) {
      typedef ::GaudiAlg::Print1D current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::GaudiAlg::Print1D

namespace ROOT {
   // Wrappers around operator new
   static void *new_GaudiAlgcLcLPrint2D(void *p) {
      return  p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::GaudiAlg::Print2D : new ::GaudiAlg::Print2D;
   }
   static void *newArray_GaudiAlgcLcLPrint2D(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::GaudiAlg::Print2D[nElements] : new ::GaudiAlg::Print2D[nElements];
   }
   // Wrapper around operator delete
   static void delete_GaudiAlgcLcLPrint2D(void *p) {
      delete ((::GaudiAlg::Print2D*)p);
   }
   static void deleteArray_GaudiAlgcLcLPrint2D(void *p) {
      delete [] ((::GaudiAlg::Print2D*)p);
   }
   static void destruct_GaudiAlgcLcLPrint2D(void *p) {
      typedef ::GaudiAlg::Print2D current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::GaudiAlg::Print2D

namespace ROOT {
   // Wrappers around operator new
   static void *new_GaudiAlgcLcLPrint3D(void *p) {
      return  p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::GaudiAlg::Print3D : new ::GaudiAlg::Print3D;
   }
   static void *newArray_GaudiAlgcLcLPrint3D(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::GaudiAlg::Print3D[nElements] : new ::GaudiAlg::Print3D[nElements];
   }
   // Wrapper around operator delete
   static void delete_GaudiAlgcLcLPrint3D(void *p) {
      delete ((::GaudiAlg::Print3D*)p);
   }
   static void deleteArray_GaudiAlgcLcLPrint3D(void *p) {
      delete [] ((::GaudiAlg::Print3D*)p);
   }
   static void destruct_GaudiAlgcLcLPrint3D(void *p) {
      typedef ::GaudiAlg::Print3D current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::GaudiAlg::Print3D

namespace ROOT {
   // Wrappers around operator new
   static void *new_GaudiAlgcLcLPrint1DProf(void *p) {
      return  p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::GaudiAlg::Print1DProf : new ::GaudiAlg::Print1DProf;
   }
   static void *newArray_GaudiAlgcLcLPrint1DProf(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::GaudiAlg::Print1DProf[nElements] : new ::GaudiAlg::Print1DProf[nElements];
   }
   // Wrapper around operator delete
   static void delete_GaudiAlgcLcLPrint1DProf(void *p) {
      delete ((::GaudiAlg::Print1DProf*)p);
   }
   static void deleteArray_GaudiAlgcLcLPrint1DProf(void *p) {
      delete [] ((::GaudiAlg::Print1DProf*)p);
   }
   static void destruct_GaudiAlgcLcLPrint1DProf(void *p) {
      typedef ::GaudiAlg::Print1DProf current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::GaudiAlg::Print1DProf

namespace ROOT {
   // Wrappers around operator new
   static void *new_GaudiAlgcLcLPrint2DProf(void *p) {
      return  p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::GaudiAlg::Print2DProf : new ::GaudiAlg::Print2DProf;
   }
   static void *newArray_GaudiAlgcLcLPrint2DProf(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::GaudiAlg::Print2DProf[nElements] : new ::GaudiAlg::Print2DProf[nElements];
   }
   // Wrapper around operator delete
   static void delete_GaudiAlgcLcLPrint2DProf(void *p) {
      delete ((::GaudiAlg::Print2DProf*)p);
   }
   static void deleteArray_GaudiAlgcLcLPrint2DProf(void *p) {
      delete [] ((::GaudiAlg::Print2DProf*)p);
   }
   static void destruct_GaudiAlgcLcLPrint2DProf(void *p) {
      typedef ::GaudiAlg::Print2DProf current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::GaudiAlg::Print2DProf

namespace ROOT {
   // Wrappers around operator new
   static void *new_GaudiAlgcLcLPrintTuple(void *p) {
      return  p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::GaudiAlg::PrintTuple : new ::GaudiAlg::PrintTuple;
   }
   static void *newArray_GaudiAlgcLcLPrintTuple(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::GaudiAlg::PrintTuple[nElements] : new ::GaudiAlg::PrintTuple[nElements];
   }
   // Wrapper around operator delete
   static void delete_GaudiAlgcLcLPrintTuple(void *p) {
      delete ((::GaudiAlg::PrintTuple*)p);
   }
   static void deleteArray_GaudiAlgcLcLPrintTuple(void *p) {
      delete [] ((::GaudiAlg::PrintTuple*)p);
   }
   static void destruct_GaudiAlgcLcLPrintTuple(void *p) {
      typedef ::GaudiAlg::PrintTuple current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::GaudiAlg::PrintTuple

namespace ROOT {
   // Wrappers around operator new
   static void *new_GaudiAlgcLcLPrintStat(void *p) {
      return  p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::GaudiAlg::PrintStat : new ::GaudiAlg::PrintStat;
   }
   static void *newArray_GaudiAlgcLcLPrintStat(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::GaudiAlg::PrintStat[nElements] : new ::GaudiAlg::PrintStat[nElements];
   }
   // Wrapper around operator delete
   static void delete_GaudiAlgcLcLPrintStat(void *p) {
      delete ((::GaudiAlg::PrintStat*)p);
   }
   static void deleteArray_GaudiAlgcLcLPrintStat(void *p) {
      delete [] ((::GaudiAlg::PrintStat*)p);
   }
   static void destruct_GaudiAlgcLcLPrintStat(void *p) {
      typedef ::GaudiAlg::PrintStat current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::GaudiAlg::PrintStat

namespace ROOT {
} // end of namespace ROOT for class ::IErrorTool

namespace ROOT {
   // Wrapper around operator delete
   static void delete_IGenericTool(void *p) {
      delete ((::IGenericTool*)p);
   }
   static void deleteArray_IGenericTool(void *p) {
      delete [] ((::IGenericTool*)p);
   }
   static void destruct_IGenericTool(void *p) {
      typedef ::IGenericTool current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::IGenericTool

namespace ROOT {
   // Wrapper around operator delete
   static void delete_IHistoTool(void *p) {
      delete ((::IHistoTool*)p);
   }
   static void deleteArray_IHistoTool(void *p) {
      delete [] ((::IHistoTool*)p);
   }
   static void destruct_IHistoTool(void *p) {
      typedef ::IHistoTool current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::IHistoTool

namespace ROOT {
   // Wrapper around operator delete
   static void delete_ISequencerTimerTool(void *p) {
      delete ((::ISequencerTimerTool*)p);
   }
   static void deleteArray_ISequencerTimerTool(void *p) {
      delete [] ((::ISequencerTimerTool*)p);
   }
   static void destruct_ISequencerTimerTool(void *p) {
      typedef ::ISequencerTimerTool current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::ISequencerTimerTool

namespace ROOT {
   // Wrappers around operator new
   static void *new_GaudicLcLUtilscLcLAida2ROOT(void *p) {
      return  p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::Gaudi::Utils::Aida2ROOT : new ::Gaudi::Utils::Aida2ROOT;
   }
   static void *newArray_GaudicLcLUtilscLcLAida2ROOT(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::Gaudi::Utils::Aida2ROOT[nElements] : new ::Gaudi::Utils::Aida2ROOT[nElements];
   }
   // Wrapper around operator delete
   static void delete_GaudicLcLUtilscLcLAida2ROOT(void *p) {
      delete ((::Gaudi::Utils::Aida2ROOT*)p);
   }
   static void deleteArray_GaudicLcLUtilscLcLAida2ROOT(void *p) {
      delete [] ((::Gaudi::Utils::Aida2ROOT*)p);
   }
   static void destruct_GaudicLcLUtilscLcLAida2ROOT(void *p) {
      typedef ::Gaudi::Utils::Aida2ROOT current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::Gaudi::Utils::Aida2ROOT

namespace ROOT {
   // Wrappers around operator new
   static void *new_GaudicLcLUtilscLcLHistoStats(void *p) {
      return  p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::Gaudi::Utils::HistoStats : new ::Gaudi::Utils::HistoStats;
   }
   static void *newArray_GaudicLcLUtilscLcLHistoStats(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::Gaudi::Utils::HistoStats[nElements] : new ::Gaudi::Utils::HistoStats[nElements];
   }
   // Wrapper around operator delete
   static void delete_GaudicLcLUtilscLcLHistoStats(void *p) {
      delete ((::Gaudi::Utils::HistoStats*)p);
   }
   static void deleteArray_GaudicLcLUtilscLcLHistoStats(void *p) {
      delete [] ((::Gaudi::Utils::HistoStats*)p);
   }
   static void destruct_GaudicLcLUtilscLcLHistoStats(void *p) {
      typedef ::Gaudi::Utils::HistoStats current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::Gaudi::Utils::HistoStats

namespace ROOT {
   // Wrappers around operator new
   static void *new_GaudicLcLUtilscLcLHistoscLcLHistoStrings(void *p) {
      return  p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::Gaudi::Utils::Histos::HistoStrings : new ::Gaudi::Utils::Histos::HistoStrings;
   }
   static void *newArray_GaudicLcLUtilscLcLHistoscLcLHistoStrings(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::Gaudi::Utils::Histos::HistoStrings[nElements] : new ::Gaudi::Utils::Histos::HistoStrings[nElements];
   }
   // Wrapper around operator delete
   static void delete_GaudicLcLUtilscLcLHistoscLcLHistoStrings(void *p) {
      delete ((::Gaudi::Utils::Histos::HistoStrings*)p);
   }
   static void deleteArray_GaudicLcLUtilscLcLHistoscLcLHistoStrings(void *p) {
      delete [] ((::Gaudi::Utils::Histos::HistoStrings*)p);
   }
   static void destruct_GaudicLcLUtilscLcLHistoscLcLHistoStrings(void *p) {
      typedef ::Gaudi::Utils::Histos::HistoStrings current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::Gaudi::Utils::Histos::HistoStrings

namespace ROOT {
   // Wrapper around operator delete
   static void delete_GaudicLcLIFileCatalog(void *p) {
      delete ((::Gaudi::IFileCatalog*)p);
   }
   static void deleteArray_GaudicLcLIFileCatalog(void *p) {
      delete [] ((::Gaudi::IFileCatalog*)p);
   }
   static void destruct_GaudicLcLIFileCatalog(void *p) {
      typedef ::Gaudi::IFileCatalog current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::Gaudi::IFileCatalog

namespace ROOT {
   // Wrapper around operator delete
   static void delete_GaudicLcLIFileCatalogMgr(void *p) {
      delete ((::Gaudi::IFileCatalogMgr*)p);
   }
   static void deleteArray_GaudicLcLIFileCatalogMgr(void *p) {
      delete [] ((::Gaudi::IFileCatalogMgr*)p);
   }
   static void destruct_GaudicLcLIFileCatalogMgr(void *p) {
      typedef ::Gaudi::IFileCatalogMgr current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::Gaudi::IFileCatalogMgr

namespace ROOT {
   // Wrapper around operator delete
   static void delete_GaudicLcLIDataConnection(void *p) {
      delete ((::Gaudi::IDataConnection*)p);
   }
   static void deleteArray_GaudicLcLIDataConnection(void *p) {
      delete [] ((::Gaudi::IDataConnection*)p);
   }
   static void destruct_GaudicLcLIDataConnection(void *p) {
      typedef ::Gaudi::IDataConnection current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::Gaudi::IDataConnection

namespace ROOT {
   // Wrapper around operator delete
   static void delete_GaudicLcLIIODataManager(void *p) {
      delete ((::Gaudi::IIODataManager*)p);
   }
   static void deleteArray_GaudicLcLIIODataManager(void *p) {
      delete [] ((::Gaudi::IIODataManager*)p);
   }
   static void destruct_GaudicLcLIIODataManager(void *p) {
      typedef ::Gaudi::IIODataManager current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::Gaudi::IIODataManager

namespace ROOT {
   // Wrappers around operator new
   static void *new___gnu_cxxcLcLdummy(void *p) {
      return  p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::__gnu_cxx::dummy : new ::__gnu_cxx::dummy;
   }
   static void *newArray___gnu_cxxcLcLdummy(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) ::__gnu_cxx::dummy[nElements] : new ::__gnu_cxx::dummy[nElements];
   }
   // Wrapper around operator delete
   static void delete___gnu_cxxcLcLdummy(void *p) {
      delete ((::__gnu_cxx::dummy*)p);
   }
   static void deleteArray___gnu_cxxcLcLdummy(void *p) {
      delete [] ((::__gnu_cxx::dummy*)p);
   }
   static void destruct___gnu_cxxcLcLdummy(void *p) {
      typedef ::__gnu_cxx::dummy current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::__gnu_cxx::dummy

namespace ROOT {
   static TClass *vectorlEvectorlEdoublegRsPgR_Dictionary();
   static void vectorlEvectorlEdoublegRsPgR_TClassManip(TClass*);
   static void *new_vectorlEvectorlEdoublegRsPgR(void *p = 0);
   static void *newArray_vectorlEvectorlEdoublegRsPgR(Long_t size, void *p);
   static void delete_vectorlEvectorlEdoublegRsPgR(void *p);
   static void deleteArray_vectorlEvectorlEdoublegRsPgR(void *p);
   static void destruct_vectorlEvectorlEdoublegRsPgR(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const vector<vector<double> >*)
   {
      vector<vector<double> > *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(vector<vector<double> >));
      static ::ROOT::TGenericClassInfo 
         instance("vector<vector<double> >", -2, "vector", 214,
                  typeid(vector<vector<double> >), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &vectorlEvectorlEdoublegRsPgR_Dictionary, isa_proxy, 4,
                  sizeof(vector<vector<double> >) );
      instance.SetNew(&new_vectorlEvectorlEdoublegRsPgR);
      instance.SetNewArray(&newArray_vectorlEvectorlEdoublegRsPgR);
      instance.SetDelete(&delete_vectorlEvectorlEdoublegRsPgR);
      instance.SetDeleteArray(&deleteArray_vectorlEvectorlEdoublegRsPgR);
      instance.SetDestructor(&destruct_vectorlEvectorlEdoublegRsPgR);
      instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::Pushback< vector<vector<double> > >()));
      return &instance;
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const vector<vector<double> >*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *vectorlEvectorlEdoublegRsPgR_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal((const vector<vector<double> >*)0x0)->GetClass();
      vectorlEvectorlEdoublegRsPgR_TClassManip(theClass);
   return theClass;
   }

   static void vectorlEvectorlEdoublegRsPgR_TClassManip(TClass* ){
   }

} // end of namespace ROOT

namespace ROOT {
   // Wrappers around operator new
   static void *new_vectorlEvectorlEdoublegRsPgR(void *p) {
      return  p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) vector<vector<double> > : new vector<vector<double> >;
   }
   static void *newArray_vectorlEvectorlEdoublegRsPgR(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) vector<vector<double> >[nElements] : new vector<vector<double> >[nElements];
   }
   // Wrapper around operator delete
   static void delete_vectorlEvectorlEdoublegRsPgR(void *p) {
      delete ((vector<vector<double> >*)p);
   }
   static void deleteArray_vectorlEvectorlEdoublegRsPgR(void *p) {
      delete [] ((vector<vector<double> >*)p);
   }
   static void destruct_vectorlEvectorlEdoublegRsPgR(void *p) {
      typedef vector<vector<double> > current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class vector<vector<double> >

namespace ROOT {
   static TClass *vectorlEstringgR_Dictionary();
   static void vectorlEstringgR_TClassManip(TClass*);
   static void *new_vectorlEstringgR(void *p = 0);
   static void *newArray_vectorlEstringgR(Long_t size, void *p);
   static void delete_vectorlEstringgR(void *p);
   static void deleteArray_vectorlEstringgR(void *p);
   static void destruct_vectorlEstringgR(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const vector<string>*)
   {
      vector<string> *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(vector<string>));
      static ::ROOT::TGenericClassInfo 
         instance("vector<string>", -2, "vector", 214,
                  typeid(vector<string>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &vectorlEstringgR_Dictionary, isa_proxy, 4,
                  sizeof(vector<string>) );
      instance.SetNew(&new_vectorlEstringgR);
      instance.SetNewArray(&newArray_vectorlEstringgR);
      instance.SetDelete(&delete_vectorlEstringgR);
      instance.SetDeleteArray(&deleteArray_vectorlEstringgR);
      instance.SetDestructor(&destruct_vectorlEstringgR);
      instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::Pushback< vector<string> >()));
      return &instance;
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const vector<string>*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *vectorlEstringgR_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal((const vector<string>*)0x0)->GetClass();
      vectorlEstringgR_TClassManip(theClass);
   return theClass;
   }

   static void vectorlEstringgR_TClassManip(TClass* ){
   }

} // end of namespace ROOT

namespace ROOT {
   // Wrappers around operator new
   static void *new_vectorlEstringgR(void *p) {
      return  p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) vector<string> : new vector<string>;
   }
   static void *newArray_vectorlEstringgR(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) vector<string>[nElements] : new vector<string>[nElements];
   }
   // Wrapper around operator delete
   static void delete_vectorlEstringgR(void *p) {
      delete ((vector<string>*)p);
   }
   static void deleteArray_vectorlEstringgR(void *p) {
      delete [] ((vector<string>*)p);
   }
   static void destruct_vectorlEstringgR(void *p) {
      typedef vector<string> current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class vector<string>

namespace ROOT {
   static TClass *vectorlEdoublegR_Dictionary();
   static void vectorlEdoublegR_TClassManip(TClass*);
   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>));
      static ::ROOT::TGenericClassInfo 
         instance("vector<double>", -2, "vector", 214,
                  typeid(vector<double>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &vectorlEdoublegR_Dictionary, isa_proxy, 4,
                  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_DICT_(Init) = GenerateInitInstanceLocal((const vector<double>*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));

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

   static void vectorlEdoublegR_TClassManip(TClass* ){
   }

} // end of namespace ROOT

namespace ROOT {
   // Wrappers around operator new
   static void *new_vectorlEdoublegR(void *p) {
      return  p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) vector<double> : new vector<double>;
   }
   static void *newArray_vectorlEdoublegR(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::Internal::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 {
   static TClass *vectorlEconstsPGaudicLcLDetailscLcLPropertyBasemUgR_Dictionary();
   static void vectorlEconstsPGaudicLcLDetailscLcLPropertyBasemUgR_TClassManip(TClass*);
   static void *new_vectorlEconstsPGaudicLcLDetailscLcLPropertyBasemUgR(void *p = 0);
   static void *newArray_vectorlEconstsPGaudicLcLDetailscLcLPropertyBasemUgR(Long_t size, void *p);
   static void delete_vectorlEconstsPGaudicLcLDetailscLcLPropertyBasemUgR(void *p);
   static void deleteArray_vectorlEconstsPGaudicLcLDetailscLcLPropertyBasemUgR(void *p);
   static void destruct_vectorlEconstsPGaudicLcLDetailscLcLPropertyBasemUgR(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const vector<const Gaudi::Details::PropertyBase*>*)
   {
      vector<const Gaudi::Details::PropertyBase*> *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(vector<const Gaudi::Details::PropertyBase*>));
      static ::ROOT::TGenericClassInfo 
         instance("vector<const Gaudi::Details::PropertyBase*>", -2, "vector", 214,
                  typeid(vector<const Gaudi::Details::PropertyBase*>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &vectorlEconstsPGaudicLcLDetailscLcLPropertyBasemUgR_Dictionary, isa_proxy, 4,
                  sizeof(vector<const Gaudi::Details::PropertyBase*>) );
      instance.SetNew(&new_vectorlEconstsPGaudicLcLDetailscLcLPropertyBasemUgR);
      instance.SetNewArray(&newArray_vectorlEconstsPGaudicLcLDetailscLcLPropertyBasemUgR);
      instance.SetDelete(&delete_vectorlEconstsPGaudicLcLDetailscLcLPropertyBasemUgR);
      instance.SetDeleteArray(&deleteArray_vectorlEconstsPGaudicLcLDetailscLcLPropertyBasemUgR);
      instance.SetDestructor(&destruct_vectorlEconstsPGaudicLcLDetailscLcLPropertyBasemUgR);
      instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::Pushback< vector<const Gaudi::Details::PropertyBase*> >()));
      return &instance;
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const vector<const Gaudi::Details::PropertyBase*>*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *vectorlEconstsPGaudicLcLDetailscLcLPropertyBasemUgR_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal((const vector<const Gaudi::Details::PropertyBase*>*)0x0)->GetClass();
      vectorlEconstsPGaudicLcLDetailscLcLPropertyBasemUgR_TClassManip(theClass);
   return theClass;
   }

   static void vectorlEconstsPGaudicLcLDetailscLcLPropertyBasemUgR_TClassManip(TClass* ){
   }

} // end of namespace ROOT

namespace ROOT {
   // Wrappers around operator new
   static void *new_vectorlEconstsPGaudicLcLDetailscLcLPropertyBasemUgR(void *p) {
      return  p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) vector<const Gaudi::Details::PropertyBase*> : new vector<const Gaudi::Details::PropertyBase*>;
   }
   static void *newArray_vectorlEconstsPGaudicLcLDetailscLcLPropertyBasemUgR(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) vector<const Gaudi::Details::PropertyBase*>[nElements] : new vector<const Gaudi::Details::PropertyBase*>[nElements];
   }
   // Wrapper around operator delete
   static void delete_vectorlEconstsPGaudicLcLDetailscLcLPropertyBasemUgR(void *p) {
      delete ((vector<const Gaudi::Details::PropertyBase*>*)p);
   }
   static void deleteArray_vectorlEconstsPGaudicLcLDetailscLcLPropertyBasemUgR(void *p) {
      delete [] ((vector<const Gaudi::Details::PropertyBase*>*)p);
   }
   static void destruct_vectorlEconstsPGaudicLcLDetailscLcLPropertyBasemUgR(void *p) {
      typedef vector<const Gaudi::Details::PropertyBase*> current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class vector<const Gaudi::Details::PropertyBase*>

namespace ROOT {
   static TClass *vectorlEStatEntitymUgR_Dictionary();
   static void vectorlEStatEntitymUgR_TClassManip(TClass*);
   static void *new_vectorlEStatEntitymUgR(void *p = 0);
   static void *newArray_vectorlEStatEntitymUgR(Long_t size, void *p);
   static void delete_vectorlEStatEntitymUgR(void *p);
   static void deleteArray_vectorlEStatEntitymUgR(void *p);
   static void destruct_vectorlEStatEntitymUgR(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const vector<StatEntity*>*)
   {
      vector<StatEntity*> *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(vector<StatEntity*>));
      static ::ROOT::TGenericClassInfo 
         instance("vector<StatEntity*>", -2, "vector", 214,
                  typeid(vector<StatEntity*>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &vectorlEStatEntitymUgR_Dictionary, isa_proxy, 4,
                  sizeof(vector<StatEntity*>) );
      instance.SetNew(&new_vectorlEStatEntitymUgR);
      instance.SetNewArray(&newArray_vectorlEStatEntitymUgR);
      instance.SetDelete(&delete_vectorlEStatEntitymUgR);
      instance.SetDeleteArray(&deleteArray_vectorlEStatEntitymUgR);
      instance.SetDestructor(&destruct_vectorlEStatEntitymUgR);
      instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::Pushback< vector<StatEntity*> >()));
      return &instance;
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const vector<StatEntity*>*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *vectorlEStatEntitymUgR_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal((const vector<StatEntity*>*)0x0)->GetClass();
      vectorlEStatEntitymUgR_TClassManip(theClass);
   return theClass;
   }

   static void vectorlEStatEntitymUgR_TClassManip(TClass* ){
   }

} // end of namespace ROOT

namespace ROOT {
   // Wrappers around operator new
   static void *new_vectorlEStatEntitymUgR(void *p) {
      return  p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) vector<StatEntity*> : new vector<StatEntity*>;
   }
   static void *newArray_vectorlEStatEntitymUgR(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) vector<StatEntity*>[nElements] : new vector<StatEntity*>[nElements];
   }
   // Wrapper around operator delete
   static void delete_vectorlEStatEntitymUgR(void *p) {
      delete ((vector<StatEntity*>*)p);
   }
   static void deleteArray_vectorlEStatEntitymUgR(void *p) {
      delete [] ((vector<StatEntity*>*)p);
   }
   static void destruct_vectorlEStatEntitymUgR(void *p) {
      typedef vector<StatEntity*> current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class vector<StatEntity*>

namespace ROOT {
   static TClass *vectorlEIServicemUgR_Dictionary();
   static void vectorlEIServicemUgR_TClassManip(TClass*);
   static void *new_vectorlEIServicemUgR(void *p = 0);
   static void *newArray_vectorlEIServicemUgR(Long_t size, void *p);
   static void delete_vectorlEIServicemUgR(void *p);
   static void deleteArray_vectorlEIServicemUgR(void *p);
   static void destruct_vectorlEIServicemUgR(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const vector<IService*>*)
   {
      vector<IService*> *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(vector<IService*>));
      static ::ROOT::TGenericClassInfo 
         instance("vector<IService*>", -2, "vector", 214,
                  typeid(vector<IService*>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &vectorlEIServicemUgR_Dictionary, isa_proxy, 4,
                  sizeof(vector<IService*>) );
      instance.SetNew(&new_vectorlEIServicemUgR);
      instance.SetNewArray(&newArray_vectorlEIServicemUgR);
      instance.SetDelete(&delete_vectorlEIServicemUgR);
      instance.SetDeleteArray(&deleteArray_vectorlEIServicemUgR);
      instance.SetDestructor(&destruct_vectorlEIServicemUgR);
      instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::Pushback< vector<IService*> >()));
      return &instance;
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const vector<IService*>*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *vectorlEIServicemUgR_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal((const vector<IService*>*)0x0)->GetClass();
      vectorlEIServicemUgR_TClassManip(theClass);
   return theClass;
   }

   static void vectorlEIServicemUgR_TClassManip(TClass* ){
   }

} // end of namespace ROOT

namespace ROOT {
   // Wrappers around operator new
   static void *new_vectorlEIServicemUgR(void *p) {
      return  p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) vector<IService*> : new vector<IService*>;
   }
   static void *newArray_vectorlEIServicemUgR(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) vector<IService*>[nElements] : new vector<IService*>[nElements];
   }
   // Wrapper around operator delete
   static void delete_vectorlEIServicemUgR(void *p) {
      delete ((vector<IService*>*)p);
   }
   static void deleteArray_vectorlEIServicemUgR(void *p) {
      delete [] ((vector<IService*>*)p);
   }
   static void destruct_vectorlEIServicemUgR(void *p) {
      typedef vector<IService*> current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class vector<IService*>

namespace ROOT {
   static TClass *vectorlEIRegistrymUgR_Dictionary();
   static void vectorlEIRegistrymUgR_TClassManip(TClass*);
   static void *new_vectorlEIRegistrymUgR(void *p = 0);
   static void *newArray_vectorlEIRegistrymUgR(Long_t size, void *p);
   static void delete_vectorlEIRegistrymUgR(void *p);
   static void deleteArray_vectorlEIRegistrymUgR(void *p);
   static void destruct_vectorlEIRegistrymUgR(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const vector<IRegistry*>*)
   {
      vector<IRegistry*> *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(vector<IRegistry*>));
      static ::ROOT::TGenericClassInfo 
         instance("vector<IRegistry*>", -2, "vector", 214,
                  typeid(vector<IRegistry*>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &vectorlEIRegistrymUgR_Dictionary, isa_proxy, 4,
                  sizeof(vector<IRegistry*>) );
      instance.SetNew(&new_vectorlEIRegistrymUgR);
      instance.SetNewArray(&newArray_vectorlEIRegistrymUgR);
      instance.SetDelete(&delete_vectorlEIRegistrymUgR);
      instance.SetDeleteArray(&deleteArray_vectorlEIRegistrymUgR);
      instance.SetDestructor(&destruct_vectorlEIRegistrymUgR);
      instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::Pushback< vector<IRegistry*> >()));
      return &instance;
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const vector<IRegistry*>*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *vectorlEIRegistrymUgR_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal((const vector<IRegistry*>*)0x0)->GetClass();
      vectorlEIRegistrymUgR_TClassManip(theClass);
   return theClass;
   }

   static void vectorlEIRegistrymUgR_TClassManip(TClass* ){
   }

} // end of namespace ROOT

namespace ROOT {
   // Wrappers around operator new
   static void *new_vectorlEIRegistrymUgR(void *p) {
      return  p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) vector<IRegistry*> : new vector<IRegistry*>;
   }
   static void *newArray_vectorlEIRegistrymUgR(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) vector<IRegistry*>[nElements] : new vector<IRegistry*>[nElements];
   }
   // Wrapper around operator delete
   static void delete_vectorlEIRegistrymUgR(void *p) {
      delete ((vector<IRegistry*>*)p);
   }
   static void deleteArray_vectorlEIRegistrymUgR(void *p) {
      delete [] ((vector<IRegistry*>*)p);
   }
   static void destruct_vectorlEIRegistrymUgR(void *p) {
      typedef vector<IRegistry*> current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class vector<IRegistry*>

namespace ROOT {
   static TClass *vectorlEIAlgToolmUgR_Dictionary();
   static void vectorlEIAlgToolmUgR_TClassManip(TClass*);
   static void *new_vectorlEIAlgToolmUgR(void *p = 0);
   static void *newArray_vectorlEIAlgToolmUgR(Long_t size, void *p);
   static void delete_vectorlEIAlgToolmUgR(void *p);
   static void deleteArray_vectorlEIAlgToolmUgR(void *p);
   static void destruct_vectorlEIAlgToolmUgR(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const vector<IAlgTool*>*)
   {
      vector<IAlgTool*> *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(vector<IAlgTool*>));
      static ::ROOT::TGenericClassInfo 
         instance("vector<IAlgTool*>", -2, "vector", 214,
                  typeid(vector<IAlgTool*>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &vectorlEIAlgToolmUgR_Dictionary, isa_proxy, 4,
                  sizeof(vector<IAlgTool*>) );
      instance.SetNew(&new_vectorlEIAlgToolmUgR);
      instance.SetNewArray(&newArray_vectorlEIAlgToolmUgR);
      instance.SetDelete(&delete_vectorlEIAlgToolmUgR);
      instance.SetDeleteArray(&deleteArray_vectorlEIAlgToolmUgR);
      instance.SetDestructor(&destruct_vectorlEIAlgToolmUgR);
      instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::Pushback< vector<IAlgTool*> >()));
      return &instance;
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const vector<IAlgTool*>*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *vectorlEIAlgToolmUgR_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal((const vector<IAlgTool*>*)0x0)->GetClass();
      vectorlEIAlgToolmUgR_TClassManip(theClass);
   return theClass;
   }

   static void vectorlEIAlgToolmUgR_TClassManip(TClass* ){
   }

} // end of namespace ROOT

namespace ROOT {
   // Wrappers around operator new
   static void *new_vectorlEIAlgToolmUgR(void *p) {
      return  p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) vector<IAlgTool*> : new vector<IAlgTool*>;
   }
   static void *newArray_vectorlEIAlgToolmUgR(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) vector<IAlgTool*>[nElements] : new vector<IAlgTool*>[nElements];
   }
   // Wrapper around operator delete
   static void delete_vectorlEIAlgToolmUgR(void *p) {
      delete ((vector<IAlgTool*>*)p);
   }
   static void deleteArray_vectorlEIAlgToolmUgR(void *p) {
      delete [] ((vector<IAlgTool*>*)p);
   }
   static void destruct_vectorlEIAlgToolmUgR(void *p) {
      typedef vector<IAlgTool*> current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class vector<IAlgTool*>

namespace ROOT {
   static TClass *vectorlEGaudiAlgcLcLIDgR_Dictionary();
   static void vectorlEGaudiAlgcLcLIDgR_TClassManip(TClass*);
   static void *new_vectorlEGaudiAlgcLcLIDgR(void *p = 0);
   static void *newArray_vectorlEGaudiAlgcLcLIDgR(Long_t size, void *p);
   static void delete_vectorlEGaudiAlgcLcLIDgR(void *p);
   static void deleteArray_vectorlEGaudiAlgcLcLIDgR(void *p);
   static void destruct_vectorlEGaudiAlgcLcLIDgR(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const vector<GaudiAlg::ID>*)
   {
      vector<GaudiAlg::ID> *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(vector<GaudiAlg::ID>));
      static ::ROOT::TGenericClassInfo 
         instance("vector<GaudiAlg::ID>", -2, "vector", 214,
                  typeid(vector<GaudiAlg::ID>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &vectorlEGaudiAlgcLcLIDgR_Dictionary, isa_proxy, 4,
                  sizeof(vector<GaudiAlg::ID>) );
      instance.SetNew(&new_vectorlEGaudiAlgcLcLIDgR);
      instance.SetNewArray(&newArray_vectorlEGaudiAlgcLcLIDgR);
      instance.SetDelete(&delete_vectorlEGaudiAlgcLcLIDgR);
      instance.SetDeleteArray(&deleteArray_vectorlEGaudiAlgcLcLIDgR);
      instance.SetDestructor(&destruct_vectorlEGaudiAlgcLcLIDgR);
      instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::Pushback< vector<GaudiAlg::ID> >()));
      return &instance;
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const vector<GaudiAlg::ID>*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *vectorlEGaudiAlgcLcLIDgR_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal((const vector<GaudiAlg::ID>*)0x0)->GetClass();
      vectorlEGaudiAlgcLcLIDgR_TClassManip(theClass);
   return theClass;
   }

   static void vectorlEGaudiAlgcLcLIDgR_TClassManip(TClass* ){
   }

} // end of namespace ROOT

namespace ROOT {
   // Wrappers around operator new
   static void *new_vectorlEGaudiAlgcLcLIDgR(void *p) {
      return  p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) vector<GaudiAlg::ID> : new vector<GaudiAlg::ID>;
   }
   static void *newArray_vectorlEGaudiAlgcLcLIDgR(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) vector<GaudiAlg::ID>[nElements] : new vector<GaudiAlg::ID>[nElements];
   }
   // Wrapper around operator delete
   static void delete_vectorlEGaudiAlgcLcLIDgR(void *p) {
      delete ((vector<GaudiAlg::ID>*)p);
   }
   static void deleteArray_vectorlEGaudiAlgcLcLIDgR(void *p) {
      delete [] ((vector<GaudiAlg::ID>*)p);
   }
   static void destruct_vectorlEGaudiAlgcLcLIDgR(void *p) {
      typedef vector<GaudiAlg::ID> current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class vector<GaudiAlg::ID>

namespace ROOT {
   static TClass *vectorlEGaudicLcLDetailscLcLPropertyBasemUgR_Dictionary();
   static void vectorlEGaudicLcLDetailscLcLPropertyBasemUgR_TClassManip(TClass*);
   static void *new_vectorlEGaudicLcLDetailscLcLPropertyBasemUgR(void *p = 0);
   static void *newArray_vectorlEGaudicLcLDetailscLcLPropertyBasemUgR(Long_t size, void *p);
   static void delete_vectorlEGaudicLcLDetailscLcLPropertyBasemUgR(void *p);
   static void deleteArray_vectorlEGaudicLcLDetailscLcLPropertyBasemUgR(void *p);
   static void destruct_vectorlEGaudicLcLDetailscLcLPropertyBasemUgR(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const vector<Gaudi::Details::PropertyBase*>*)
   {
      vector<Gaudi::Details::PropertyBase*> *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(vector<Gaudi::Details::PropertyBase*>));
      static ::ROOT::TGenericClassInfo 
         instance("vector<Gaudi::Details::PropertyBase*>", -2, "vector", 214,
                  typeid(vector<Gaudi::Details::PropertyBase*>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &vectorlEGaudicLcLDetailscLcLPropertyBasemUgR_Dictionary, isa_proxy, 4,
                  sizeof(vector<Gaudi::Details::PropertyBase*>) );
      instance.SetNew(&new_vectorlEGaudicLcLDetailscLcLPropertyBasemUgR);
      instance.SetNewArray(&newArray_vectorlEGaudicLcLDetailscLcLPropertyBasemUgR);
      instance.SetDelete(&delete_vectorlEGaudicLcLDetailscLcLPropertyBasemUgR);
      instance.SetDeleteArray(&deleteArray_vectorlEGaudicLcLDetailscLcLPropertyBasemUgR);
      instance.SetDestructor(&destruct_vectorlEGaudicLcLDetailscLcLPropertyBasemUgR);
      instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::Pushback< vector<Gaudi::Details::PropertyBase*> >()));
      return &instance;
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const vector<Gaudi::Details::PropertyBase*>*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *vectorlEGaudicLcLDetailscLcLPropertyBasemUgR_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal((const vector<Gaudi::Details::PropertyBase*>*)0x0)->GetClass();
      vectorlEGaudicLcLDetailscLcLPropertyBasemUgR_TClassManip(theClass);
   return theClass;
   }

   static void vectorlEGaudicLcLDetailscLcLPropertyBasemUgR_TClassManip(TClass* ){
   }

} // end of namespace ROOT

namespace ROOT {
   // Wrappers around operator new
   static void *new_vectorlEGaudicLcLDetailscLcLPropertyBasemUgR(void *p) {
      return  p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) vector<Gaudi::Details::PropertyBase*> : new vector<Gaudi::Details::PropertyBase*>;
   }
   static void *newArray_vectorlEGaudicLcLDetailscLcLPropertyBasemUgR(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) vector<Gaudi::Details::PropertyBase*>[nElements] : new vector<Gaudi::Details::PropertyBase*>[nElements];
   }
   // Wrapper around operator delete
   static void delete_vectorlEGaudicLcLDetailscLcLPropertyBasemUgR(void *p) {
      delete ((vector<Gaudi::Details::PropertyBase*>*)p);
   }
   static void deleteArray_vectorlEGaudicLcLDetailscLcLPropertyBasemUgR(void *p) {
      delete [] ((vector<Gaudi::Details::PropertyBase*>*)p);
   }
   static void destruct_vectorlEGaudicLcLDetailscLcLPropertyBasemUgR(void *p) {
      typedef vector<Gaudi::Details::PropertyBase*> current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class vector<Gaudi::Details::PropertyBase*>

namespace ROOT {
   static TClass *vectorlEAIDAcLcLIProfile2DmUgR_Dictionary();
   static void vectorlEAIDAcLcLIProfile2DmUgR_TClassManip(TClass*);
   static void *new_vectorlEAIDAcLcLIProfile2DmUgR(void *p = 0);
   static void *newArray_vectorlEAIDAcLcLIProfile2DmUgR(Long_t size, void *p);
   static void delete_vectorlEAIDAcLcLIProfile2DmUgR(void *p);
   static void deleteArray_vectorlEAIDAcLcLIProfile2DmUgR(void *p);
   static void destruct_vectorlEAIDAcLcLIProfile2DmUgR(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const vector<AIDA::IProfile2D*>*)
   {
      vector<AIDA::IProfile2D*> *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(vector<AIDA::IProfile2D*>));
      static ::ROOT::TGenericClassInfo 
         instance("vector<AIDA::IProfile2D*>", -2, "vector", 214,
                  typeid(vector<AIDA::IProfile2D*>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &vectorlEAIDAcLcLIProfile2DmUgR_Dictionary, isa_proxy, 4,
                  sizeof(vector<AIDA::IProfile2D*>) );
      instance.SetNew(&new_vectorlEAIDAcLcLIProfile2DmUgR);
      instance.SetNewArray(&newArray_vectorlEAIDAcLcLIProfile2DmUgR);
      instance.SetDelete(&delete_vectorlEAIDAcLcLIProfile2DmUgR);
      instance.SetDeleteArray(&deleteArray_vectorlEAIDAcLcLIProfile2DmUgR);
      instance.SetDestructor(&destruct_vectorlEAIDAcLcLIProfile2DmUgR);
      instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::Pushback< vector<AIDA::IProfile2D*> >()));
      return &instance;
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const vector<AIDA::IProfile2D*>*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *vectorlEAIDAcLcLIProfile2DmUgR_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal((const vector<AIDA::IProfile2D*>*)0x0)->GetClass();
      vectorlEAIDAcLcLIProfile2DmUgR_TClassManip(theClass);
   return theClass;
   }

   static void vectorlEAIDAcLcLIProfile2DmUgR_TClassManip(TClass* ){
   }

} // end of namespace ROOT

namespace ROOT {
   // Wrappers around operator new
   static void *new_vectorlEAIDAcLcLIProfile2DmUgR(void *p) {
      return  p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) vector<AIDA::IProfile2D*> : new vector<AIDA::IProfile2D*>;
   }
   static void *newArray_vectorlEAIDAcLcLIProfile2DmUgR(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) vector<AIDA::IProfile2D*>[nElements] : new vector<AIDA::IProfile2D*>[nElements];
   }
   // Wrapper around operator delete
   static void delete_vectorlEAIDAcLcLIProfile2DmUgR(void *p) {
      delete ((vector<AIDA::IProfile2D*>*)p);
   }
   static void deleteArray_vectorlEAIDAcLcLIProfile2DmUgR(void *p) {
      delete [] ((vector<AIDA::IProfile2D*>*)p);
   }
   static void destruct_vectorlEAIDAcLcLIProfile2DmUgR(void *p) {
      typedef vector<AIDA::IProfile2D*> current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class vector<AIDA::IProfile2D*>

namespace ROOT {
   static TClass *vectorlEAIDAcLcLIProfile1DmUgR_Dictionary();
   static void vectorlEAIDAcLcLIProfile1DmUgR_TClassManip(TClass*);
   static void *new_vectorlEAIDAcLcLIProfile1DmUgR(void *p = 0);
   static void *newArray_vectorlEAIDAcLcLIProfile1DmUgR(Long_t size, void *p);
   static void delete_vectorlEAIDAcLcLIProfile1DmUgR(void *p);
   static void deleteArray_vectorlEAIDAcLcLIProfile1DmUgR(void *p);
   static void destruct_vectorlEAIDAcLcLIProfile1DmUgR(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const vector<AIDA::IProfile1D*>*)
   {
      vector<AIDA::IProfile1D*> *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(vector<AIDA::IProfile1D*>));
      static ::ROOT::TGenericClassInfo 
         instance("vector<AIDA::IProfile1D*>", -2, "vector", 214,
                  typeid(vector<AIDA::IProfile1D*>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &vectorlEAIDAcLcLIProfile1DmUgR_Dictionary, isa_proxy, 4,
                  sizeof(vector<AIDA::IProfile1D*>) );
      instance.SetNew(&new_vectorlEAIDAcLcLIProfile1DmUgR);
      instance.SetNewArray(&newArray_vectorlEAIDAcLcLIProfile1DmUgR);
      instance.SetDelete(&delete_vectorlEAIDAcLcLIProfile1DmUgR);
      instance.SetDeleteArray(&deleteArray_vectorlEAIDAcLcLIProfile1DmUgR);
      instance.SetDestructor(&destruct_vectorlEAIDAcLcLIProfile1DmUgR);
      instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::Pushback< vector<AIDA::IProfile1D*> >()));
      return &instance;
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const vector<AIDA::IProfile1D*>*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *vectorlEAIDAcLcLIProfile1DmUgR_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal((const vector<AIDA::IProfile1D*>*)0x0)->GetClass();
      vectorlEAIDAcLcLIProfile1DmUgR_TClassManip(theClass);
   return theClass;
   }

   static void vectorlEAIDAcLcLIProfile1DmUgR_TClassManip(TClass* ){
   }

} // end of namespace ROOT

namespace ROOT {
   // Wrappers around operator new
   static void *new_vectorlEAIDAcLcLIProfile1DmUgR(void *p) {
      return  p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) vector<AIDA::IProfile1D*> : new vector<AIDA::IProfile1D*>;
   }
   static void *newArray_vectorlEAIDAcLcLIProfile1DmUgR(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) vector<AIDA::IProfile1D*>[nElements] : new vector<AIDA::IProfile1D*>[nElements];
   }
   // Wrapper around operator delete
   static void delete_vectorlEAIDAcLcLIProfile1DmUgR(void *p) {
      delete ((vector<AIDA::IProfile1D*>*)p);
   }
   static void deleteArray_vectorlEAIDAcLcLIProfile1DmUgR(void *p) {
      delete [] ((vector<AIDA::IProfile1D*>*)p);
   }
   static void destruct_vectorlEAIDAcLcLIProfile1DmUgR(void *p) {
      typedef vector<AIDA::IProfile1D*> current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class vector<AIDA::IProfile1D*>

namespace ROOT {
   static TClass *vectorlEAIDAcLcLIHistogram3DmUgR_Dictionary();
   static void vectorlEAIDAcLcLIHistogram3DmUgR_TClassManip(TClass*);
   static void *new_vectorlEAIDAcLcLIHistogram3DmUgR(void *p = 0);
   static void *newArray_vectorlEAIDAcLcLIHistogram3DmUgR(Long_t size, void *p);
   static void delete_vectorlEAIDAcLcLIHistogram3DmUgR(void *p);
   static void deleteArray_vectorlEAIDAcLcLIHistogram3DmUgR(void *p);
   static void destruct_vectorlEAIDAcLcLIHistogram3DmUgR(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const vector<AIDA::IHistogram3D*>*)
   {
      vector<AIDA::IHistogram3D*> *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(vector<AIDA::IHistogram3D*>));
      static ::ROOT::TGenericClassInfo 
         instance("vector<AIDA::IHistogram3D*>", -2, "vector", 214,
                  typeid(vector<AIDA::IHistogram3D*>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &vectorlEAIDAcLcLIHistogram3DmUgR_Dictionary, isa_proxy, 4,
                  sizeof(vector<AIDA::IHistogram3D*>) );
      instance.SetNew(&new_vectorlEAIDAcLcLIHistogram3DmUgR);
      instance.SetNewArray(&newArray_vectorlEAIDAcLcLIHistogram3DmUgR);
      instance.SetDelete(&delete_vectorlEAIDAcLcLIHistogram3DmUgR);
      instance.SetDeleteArray(&deleteArray_vectorlEAIDAcLcLIHistogram3DmUgR);
      instance.SetDestructor(&destruct_vectorlEAIDAcLcLIHistogram3DmUgR);
      instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::Pushback< vector<AIDA::IHistogram3D*> >()));
      return &instance;
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const vector<AIDA::IHistogram3D*>*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *vectorlEAIDAcLcLIHistogram3DmUgR_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal((const vector<AIDA::IHistogram3D*>*)0x0)->GetClass();
      vectorlEAIDAcLcLIHistogram3DmUgR_TClassManip(theClass);
   return theClass;
   }

   static void vectorlEAIDAcLcLIHistogram3DmUgR_TClassManip(TClass* ){
   }

} // end of namespace ROOT

namespace ROOT {
   // Wrappers around operator new
   static void *new_vectorlEAIDAcLcLIHistogram3DmUgR(void *p) {
      return  p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) vector<AIDA::IHistogram3D*> : new vector<AIDA::IHistogram3D*>;
   }
   static void *newArray_vectorlEAIDAcLcLIHistogram3DmUgR(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) vector<AIDA::IHistogram3D*>[nElements] : new vector<AIDA::IHistogram3D*>[nElements];
   }
   // Wrapper around operator delete
   static void delete_vectorlEAIDAcLcLIHistogram3DmUgR(void *p) {
      delete ((vector<AIDA::IHistogram3D*>*)p);
   }
   static void deleteArray_vectorlEAIDAcLcLIHistogram3DmUgR(void *p) {
      delete [] ((vector<AIDA::IHistogram3D*>*)p);
   }
   static void destruct_vectorlEAIDAcLcLIHistogram3DmUgR(void *p) {
      typedef vector<AIDA::IHistogram3D*> current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class vector<AIDA::IHistogram3D*>

namespace ROOT {
   static TClass *vectorlEAIDAcLcLIHistogram2DmUgR_Dictionary();
   static void vectorlEAIDAcLcLIHistogram2DmUgR_TClassManip(TClass*);
   static void *new_vectorlEAIDAcLcLIHistogram2DmUgR(void *p = 0);
   static void *newArray_vectorlEAIDAcLcLIHistogram2DmUgR(Long_t size, void *p);
   static void delete_vectorlEAIDAcLcLIHistogram2DmUgR(void *p);
   static void deleteArray_vectorlEAIDAcLcLIHistogram2DmUgR(void *p);
   static void destruct_vectorlEAIDAcLcLIHistogram2DmUgR(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const vector<AIDA::IHistogram2D*>*)
   {
      vector<AIDA::IHistogram2D*> *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(vector<AIDA::IHistogram2D*>));
      static ::ROOT::TGenericClassInfo 
         instance("vector<AIDA::IHistogram2D*>", -2, "vector", 214,
                  typeid(vector<AIDA::IHistogram2D*>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &vectorlEAIDAcLcLIHistogram2DmUgR_Dictionary, isa_proxy, 4,
                  sizeof(vector<AIDA::IHistogram2D*>) );
      instance.SetNew(&new_vectorlEAIDAcLcLIHistogram2DmUgR);
      instance.SetNewArray(&newArray_vectorlEAIDAcLcLIHistogram2DmUgR);
      instance.SetDelete(&delete_vectorlEAIDAcLcLIHistogram2DmUgR);
      instance.SetDeleteArray(&deleteArray_vectorlEAIDAcLcLIHistogram2DmUgR);
      instance.SetDestructor(&destruct_vectorlEAIDAcLcLIHistogram2DmUgR);
      instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::Pushback< vector<AIDA::IHistogram2D*> >()));
      return &instance;
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const vector<AIDA::IHistogram2D*>*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *vectorlEAIDAcLcLIHistogram2DmUgR_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal((const vector<AIDA::IHistogram2D*>*)0x0)->GetClass();
      vectorlEAIDAcLcLIHistogram2DmUgR_TClassManip(theClass);
   return theClass;
   }

   static void vectorlEAIDAcLcLIHistogram2DmUgR_TClassManip(TClass* ){
   }

} // end of namespace ROOT

namespace ROOT {
   // Wrappers around operator new
   static void *new_vectorlEAIDAcLcLIHistogram2DmUgR(void *p) {
      return  p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) vector<AIDA::IHistogram2D*> : new vector<AIDA::IHistogram2D*>;
   }
   static void *newArray_vectorlEAIDAcLcLIHistogram2DmUgR(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) vector<AIDA::IHistogram2D*>[nElements] : new vector<AIDA::IHistogram2D*>[nElements];
   }
   // Wrapper around operator delete
   static void delete_vectorlEAIDAcLcLIHistogram2DmUgR(void *p) {
      delete ((vector<AIDA::IHistogram2D*>*)p);
   }
   static void deleteArray_vectorlEAIDAcLcLIHistogram2DmUgR(void *p) {
      delete [] ((vector<AIDA::IHistogram2D*>*)p);
   }
   static void destruct_vectorlEAIDAcLcLIHistogram2DmUgR(void *p) {
      typedef vector<AIDA::IHistogram2D*> current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class vector<AIDA::IHistogram2D*>

namespace ROOT {
   static TClass *vectorlEAIDAcLcLIHistogram1DmUgR_Dictionary();
   static void vectorlEAIDAcLcLIHistogram1DmUgR_TClassManip(TClass*);
   static void *new_vectorlEAIDAcLcLIHistogram1DmUgR(void *p = 0);
   static void *newArray_vectorlEAIDAcLcLIHistogram1DmUgR(Long_t size, void *p);
   static void delete_vectorlEAIDAcLcLIHistogram1DmUgR(void *p);
   static void deleteArray_vectorlEAIDAcLcLIHistogram1DmUgR(void *p);
   static void destruct_vectorlEAIDAcLcLIHistogram1DmUgR(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const vector<AIDA::IHistogram1D*>*)
   {
      vector<AIDA::IHistogram1D*> *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(vector<AIDA::IHistogram1D*>));
      static ::ROOT::TGenericClassInfo 
         instance("vector<AIDA::IHistogram1D*>", -2, "vector", 214,
                  typeid(vector<AIDA::IHistogram1D*>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &vectorlEAIDAcLcLIHistogram1DmUgR_Dictionary, isa_proxy, 4,
                  sizeof(vector<AIDA::IHistogram1D*>) );
      instance.SetNew(&new_vectorlEAIDAcLcLIHistogram1DmUgR);
      instance.SetNewArray(&newArray_vectorlEAIDAcLcLIHistogram1DmUgR);
      instance.SetDelete(&delete_vectorlEAIDAcLcLIHistogram1DmUgR);
      instance.SetDeleteArray(&deleteArray_vectorlEAIDAcLcLIHistogram1DmUgR);
      instance.SetDestructor(&destruct_vectorlEAIDAcLcLIHistogram1DmUgR);
      instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::Pushback< vector<AIDA::IHistogram1D*> >()));
      return &instance;
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const vector<AIDA::IHistogram1D*>*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *vectorlEAIDAcLcLIHistogram1DmUgR_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal((const vector<AIDA::IHistogram1D*>*)0x0)->GetClass();
      vectorlEAIDAcLcLIHistogram1DmUgR_TClassManip(theClass);
   return theClass;
   }

   static void vectorlEAIDAcLcLIHistogram1DmUgR_TClassManip(TClass* ){
   }

} // end of namespace ROOT

namespace ROOT {
   // Wrappers around operator new
   static void *new_vectorlEAIDAcLcLIHistogram1DmUgR(void *p) {
      return  p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) vector<AIDA::IHistogram1D*> : new vector<AIDA::IHistogram1D*>;
   }
   static void *newArray_vectorlEAIDAcLcLIHistogram1DmUgR(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) vector<AIDA::IHistogram1D*>[nElements] : new vector<AIDA::IHistogram1D*>[nElements];
   }
   // Wrapper around operator delete
   static void delete_vectorlEAIDAcLcLIHistogram1DmUgR(void *p) {
      delete ((vector<AIDA::IHistogram1D*>*)p);
   }
   static void deleteArray_vectorlEAIDAcLcLIHistogram1DmUgR(void *p) {
      delete [] ((vector<AIDA::IHistogram1D*>*)p);
   }
   static void destruct_vectorlEAIDAcLcLIHistogram1DmUgR(void *p) {
      typedef vector<AIDA::IHistogram1D*> current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class vector<AIDA::IHistogram1D*>

namespace ROOT {
   static TClass *maplEstringcOstringgR_Dictionary();
   static void maplEstringcOstringgR_TClassManip(TClass*);
   static void *new_maplEstringcOstringgR(void *p = 0);
   static void *newArray_maplEstringcOstringgR(Long_t size, void *p);
   static void delete_maplEstringcOstringgR(void *p);
   static void deleteArray_maplEstringcOstringgR(void *p);
   static void destruct_maplEstringcOstringgR(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const map<string,string>*)
   {
      map<string,string> *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(map<string,string>));
      static ::ROOT::TGenericClassInfo 
         instance("map<string,string>", -2, "map", 96,
                  typeid(map<string,string>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &maplEstringcOstringgR_Dictionary, isa_proxy, 4,
                  sizeof(map<string,string>) );
      instance.SetNew(&new_maplEstringcOstringgR);
      instance.SetNewArray(&newArray_maplEstringcOstringgR);
      instance.SetDelete(&delete_maplEstringcOstringgR);
      instance.SetDeleteArray(&deleteArray_maplEstringcOstringgR);
      instance.SetDestructor(&destruct_maplEstringcOstringgR);
      instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::MapInsert< map<string,string> >()));
      return &instance;
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const map<string,string>*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *maplEstringcOstringgR_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal((const map<string,string>*)0x0)->GetClass();
      maplEstringcOstringgR_TClassManip(theClass);
   return theClass;
   }

   static void maplEstringcOstringgR_TClassManip(TClass* ){
   }

} // end of namespace ROOT

namespace ROOT {
   // Wrappers around operator new
   static void *new_maplEstringcOstringgR(void *p) {
      return  p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) map<string,string> : new map<string,string>;
   }
   static void *newArray_maplEstringcOstringgR(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) map<string,string>[nElements] : new map<string,string>[nElements];
   }
   // Wrapper around operator delete
   static void delete_maplEstringcOstringgR(void *p) {
      delete ((map<string,string>*)p);
   }
   static void deleteArray_maplEstringcOstringgR(void *p) {
      delete [] ((map<string,string>*)p);
   }
   static void destruct_maplEstringcOstringgR(void *p) {
      typedef map<string,string> current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class map<string,string>

namespace ROOT {
   static TClass *listlEIServicemUgR_Dictionary();
   static void listlEIServicemUgR_TClassManip(TClass*);
   static void *new_listlEIServicemUgR(void *p = 0);
   static void *newArray_listlEIServicemUgR(Long_t size, void *p);
   static void delete_listlEIServicemUgR(void *p);
   static void deleteArray_listlEIServicemUgR(void *p);
   static void destruct_listlEIServicemUgR(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const list<IService*>*)
   {
      list<IService*> *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(list<IService*>));
      static ::ROOT::TGenericClassInfo 
         instance("list<IService*>", -2, "list", 503,
                  typeid(list<IService*>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &listlEIServicemUgR_Dictionary, isa_proxy, 4,
                  sizeof(list<IService*>) );
      instance.SetNew(&new_listlEIServicemUgR);
      instance.SetNewArray(&newArray_listlEIServicemUgR);
      instance.SetDelete(&delete_listlEIServicemUgR);
      instance.SetDeleteArray(&deleteArray_listlEIServicemUgR);
      instance.SetDestructor(&destruct_listlEIServicemUgR);
      instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::Pushback< list<IService*> >()));
      return &instance;
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const list<IService*>*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *listlEIServicemUgR_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal((const list<IService*>*)0x0)->GetClass();
      listlEIServicemUgR_TClassManip(theClass);
   return theClass;
   }

   static void listlEIServicemUgR_TClassManip(TClass* ){
   }

} // end of namespace ROOT

namespace ROOT {
   // Wrappers around operator new
   static void *new_listlEIServicemUgR(void *p) {
      return  p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) list<IService*> : new list<IService*>;
   }
   static void *newArray_listlEIServicemUgR(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) list<IService*>[nElements] : new list<IService*>[nElements];
   }
   // Wrapper around operator delete
   static void delete_listlEIServicemUgR(void *p) {
      delete ((list<IService*>*)p);
   }
   static void deleteArray_listlEIServicemUgR(void *p) {
      delete [] ((list<IService*>*)p);
   }
   static void destruct_listlEIServicemUgR(void *p) {
      typedef list<IService*> current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class list<IService*>

namespace ROOT {
   static TClass *listlEIAlgorithmmUgR_Dictionary();
   static void listlEIAlgorithmmUgR_TClassManip(TClass*);
   static void *new_listlEIAlgorithmmUgR(void *p = 0);
   static void *newArray_listlEIAlgorithmmUgR(Long_t size, void *p);
   static void delete_listlEIAlgorithmmUgR(void *p);
   static void deleteArray_listlEIAlgorithmmUgR(void *p);
   static void destruct_listlEIAlgorithmmUgR(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const list<IAlgorithm*>*)
   {
      list<IAlgorithm*> *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(list<IAlgorithm*>));
      static ::ROOT::TGenericClassInfo 
         instance("list<IAlgorithm*>", -2, "list", 503,
                  typeid(list<IAlgorithm*>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &listlEIAlgorithmmUgR_Dictionary, isa_proxy, 4,
                  sizeof(list<IAlgorithm*>) );
      instance.SetNew(&new_listlEIAlgorithmmUgR);
      instance.SetNewArray(&newArray_listlEIAlgorithmmUgR);
      instance.SetDelete(&delete_listlEIAlgorithmmUgR);
      instance.SetDeleteArray(&deleteArray_listlEIAlgorithmmUgR);
      instance.SetDestructor(&destruct_listlEIAlgorithmmUgR);
      instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::Pushback< list<IAlgorithm*> >()));
      return &instance;
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const list<IAlgorithm*>*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *listlEIAlgorithmmUgR_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal((const list<IAlgorithm*>*)0x0)->GetClass();
      listlEIAlgorithmmUgR_TClassManip(theClass);
   return theClass;
   }

   static void listlEIAlgorithmmUgR_TClassManip(TClass* ){
   }

} // end of namespace ROOT

namespace ROOT {
   // Wrappers around operator new
   static void *new_listlEIAlgorithmmUgR(void *p) {
      return  p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) list<IAlgorithm*> : new list<IAlgorithm*>;
   }
   static void *newArray_listlEIAlgorithmmUgR(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) list<IAlgorithm*>[nElements] : new list<IAlgorithm*>[nElements];
   }
   // Wrapper around operator delete
   static void delete_listlEIAlgorithmmUgR(void *p) {
      delete ((list<IAlgorithm*>*)p);
   }
   static void deleteArray_listlEIAlgorithmmUgR(void *p) {
      delete [] ((list<IAlgorithm*>*)p);
   }
   static void destruct_listlEIAlgorithmmUgR(void *p) {
      typedef list<IAlgorithm*> current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class list<IAlgorithm*>

namespace {
  void TriggerDictionaryInitialization_GaudiPythonDict_Impl() {
    static const char* headers[] = {
0    };
    static const char* includePaths[] = {
"/builds/gaudi/Gaudi/GaudiPython",
"/builds/gaudi/Gaudi/GaudiPluginService",
"/builds/gaudi/Gaudi/GaudiKernel",
"/builds/gaudi/Gaudi/GaudiUtils",
"/builds/gaudi/Gaudi/GaudiAlg",
"/cvmfs/sft.cern.ch/lcg/releases/LCG_93/Python/2.7.13/x86_64-centos7-gcc62-opt/include/python2.7",
"/cvmfs/sft.cern.ch/lcg/releases/LCG_93/clhep/2.4.0.1/x86_64-centos7-gcc62-opt/include",
"/cvmfs/sft.cern.ch/lcg/releases/LCG_93/rangev3/0.3.0/x86_64-centos7-gcc62-opt/include",
"/cvmfs/sft.cern.ch/lcg/releases/LCG_93/AIDA/3.2.1/x86_64-centos7-gcc62-opt/src/cpp",
"/cvmfs/sft.cern.ch/lcg/releases/LCG_93/tbb/2018_U1/x86_64-centos7-gcc62-opt/include",
"/cvmfs/sft.cern.ch/lcg/releases/LCG_93/ROOT/6.12.06/x86_64-centos7-gcc62-opt/include",
"/cvmfs/sft.cern.ch/lcg/releases/LCG_93/Boost/1.66.0/x86_64-centos7-gcc62-opt/include",
"/builds/gaudi/Gaudi/build-gcc62/include",
"/cvmfs/sft.cern.ch/lcg/releases/ROOT/6.12.06-51921/x86_64-centos7-gcc62-opt/include",
"/builds/gaudi/Gaudi/build-gcc62/GaudiPython/",
0
    };
    static const char* fwdDeclCode = R"DICTFWDDCLS(
#line 1 "GaudiPythonDict dictionary forward declarations' payload"
#pragma clang diagnostic ignored "-Wkeyword-compat"
#pragma clang diagnostic ignored "-Wignored-attributes"
#pragma clang diagnostic ignored "-Wreturn-type-c-linkage"
extern int __Cling_Autoloading_Map;
class __attribute__((annotate("$clingAutoload$GaudiKernel/IService.h")))  __attribute__((annotate("$clingAutoload$GaudiKernel/Algorithm.h")))  IService;
namespace std{template <typename _Tp> class __attribute__((annotate("$clingAutoload$bits/allocator.h")))  __attribute__((annotate("$clingAutoload$string")))  allocator;
}
class __attribute__((annotate("$clingAutoload$GaudiKernel/IAlgorithm.h")))  __attribute__((annotate("$clingAutoload$GaudiKernel/Algorithm.h")))  IAlgorithm;
class __attribute__((annotate("$clingAutoload$GaudiKernel/IRegistry.h")))  __attribute__((annotate("$clingAutoload$GaudiPython/AlgDecorators.h")))  IRegistry;
namespace std{template <class _CharT> struct __attribute__((annotate("$clingAutoload$bits/char_traits.h")))  __attribute__((annotate("$clingAutoload$string")))  char_traits;
}
namespace Gaudi{namespace Details{class __attribute__((annotate("$clingAutoload$GaudiKernel/Property.h")))  __attribute__((annotate("$clingAutoload$GaudiKernel/Algorithm.h")))  PropertyBase;}}
class __attribute__((annotate("$clingAutoload$GaudiKernel/IAlgTool.h")))  __attribute__((annotate("$clingAutoload$GaudiKernel/Algorithm.h")))  IAlgTool;
namespace GaudiAlg{class __attribute__((annotate(R"ATTRDUMP(pattern@@@GaudiAlg::*)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$GaudiAlg/GaudiHistoID.h")))  __attribute__((annotate("$clingAutoload$GaudiPython/HistoDecorator.h")))  ID;}
namespace AIDA{class __attribute__((annotate(R"ATTRDUMP(pattern@@@AIDA::I*)ATTRDUMP"))) IHistogram1D;}
namespace AIDA{class __attribute__((annotate(R"ATTRDUMP(pattern@@@AIDA::I*)ATTRDUMP"))) IHistogram2D;}
namespace AIDA{class __attribute__((annotate(R"ATTRDUMP(pattern@@@AIDA::I*)ATTRDUMP"))) IHistogram3D;}
namespace AIDA{class __attribute__((annotate(R"ATTRDUMP(pattern@@@AIDA::I*)ATTRDUMP"))) IProfile1D;}
namespace AIDA{class __attribute__((annotate(R"ATTRDUMP(pattern@@@AIDA::I*)ATTRDUMP"))) IProfile2D;}
class __attribute__((annotate("$clingAutoload$GaudiKernel/Counters.h")))  __attribute__((annotate("$clingAutoload$GaudiKernel/Chrono.h")))  StatEntity;
namespace std{struct __attribute__((annotate(R"ATTRDUMP(pattern@@@std::_Bit_reference*)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$bits/stl_bvector.h")))  __attribute__((annotate("$clingAutoload$GaudiKernel/Algorithm.h")))  _Bit_reference;}
namespace Gaudi{namespace Utils{class __attribute__((annotate("$clingAutoload$GaudiKernel/MapBase.h")))  __attribute__((annotate("$clingAutoload$GaudiKernel/Algorithm.h")))  MapBase;}}
namespace Gaudi{class __attribute__((annotate("$clingAutoload$GaudiKernel/StringKey.h")))  __attribute__((annotate("$clingAutoload$GaudiKernel/Algorithm.h")))  StringKey;}
class __attribute__((annotate(R"ATTRDUMP(pattern@@@Chrono*)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$GaudiKernel/ChronoEntity.h")))  __attribute__((annotate("$clingAutoload$GaudiKernel/Chrono.h")))  ChronoEntity;
class __attribute__((annotate(R"ATTRDUMP(pattern@@@Chrono*)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$GaudiKernel/Chrono.h")))  Chrono;
class __attribute__((annotate("$clingAutoload$GaudiKernel/ParticleProperty.h")))  ParticleProperty;
namespace Gaudi{struct __attribute__((annotate("$clingAutoload$GaudiKernel/Range.h")))  RangeBase_;}
class __attribute__((annotate("$clingAutoload$GaudiKernel/Stat.h")))  Stat;
namespace AIDA{class __attribute__((annotate(R"ATTRDUMP(pattern@@@AIDA::I*)ATTRDUMP"))) IAxis;}
namespace AIDA{class __attribute__((annotate(R"ATTRDUMP(pattern@@@AIDA::I*)ATTRDUMP"))) IBaseHistogram;}
namespace AIDA{class __attribute__((annotate(R"ATTRDUMP(pattern@@@AIDA::I*)ATTRDUMP"))) IHistogram;}
namespace AIDA{class __attribute__((annotate(R"ATTRDUMP(pattern@@@AIDA::I*)ATTRDUMP"))) IProfile;}
namespace GaudiPython{struct __attribute__((annotate("$clingAutoload$GaudiPython/Helpers.h")))  Helper;}
class __attribute__((annotate("$clingAutoload$GaudiKernel/Algorithm.h")))  Algorithm;
template <class BASE> class __attribute__((annotate("$clingAutoload$GaudiAlg/GetData.h")))  __attribute__((annotate("$clingAutoload$GaudiPython/AlgDecorators.h")))  GaudiCommon;

class __attribute__((annotate("$clingAutoload$GaudiKernel/AlgTool.h")))  __attribute__((annotate("$clingAutoload$GaudiPython/HistoDecorator.h")))  AlgTool;
class __attribute__((annotate("$clingAutoload$GaudiAlg/GaudiAlgorithm.h")))  __attribute__((annotate("$clingAutoload$GaudiPython/AlgDecorators.h")))  GaudiAlgorithm;
namespace GaudiPython{class __attribute__((annotate(R"ATTRDUMP(pattern@@@GaudiPython::*Decorator*)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$GaudiPython/AlgDecorators.h")))  AlgDecorator;}
namespace GaudiPython{class __attribute__((annotate("$clingAutoload$GaudiPython/Algorithm.h")))  PyAlgorithm;}
namespace GaudiPython{template <class ALGORITHM> class __attribute__((annotate("$clingAutoload$GaudiPython/Algorithm.h")))  PyAlg;
}
struct __attribute__((annotate("$clingAutoload$GaudiAlg/GaudiHistoAlg.h")))  __attribute__((annotate("$clingAutoload$GaudiPython/HistoDecorator.h")))  GaudiHistoAlg;
struct __attribute__((annotate("$clingAutoload$GaudiAlg/GaudiTupleAlg.h")))  __attribute__((annotate("$clingAutoload$GaudiPython/TupleDecorator.h")))  GaudiTupleAlg;
namespace GaudiPython{class __attribute__((annotate("$clingAutoload$GaudiPython/CallbackStreamBuf.h")))  CallbackStreamBuf;}
namespace Gaudi{namespace Utils{namespace Histos{class __attribute__((annotate("$clingAutoload$GaudiUtils/HistoTableFormat.h")))  __attribute__((annotate("$clingAutoload$GaudiPython/HistoDecorator.h")))  Table;}}}
template <class PBASE> class __attribute__((annotate("$clingAutoload$GaudiAlg/GaudiHistos.h")))  __attribute__((annotate("$clingAutoload$GaudiPython/HistoDecorator.h")))  GaudiHistos;

class __attribute__((annotate("$clingAutoload$GaudiAlg/GaudiTool.h")))  __attribute__((annotate("$clingAutoload$GaudiPython/HistoDecorator.h")))  GaudiTool;
namespace GaudiPython{class __attribute__((annotate(R"ATTRDUMP(pattern@@@GaudiPython::*Decorator*)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$GaudiPython/HistoDecorator.h")))  HistoDecorator;}
class __attribute__((annotate("$clingAutoload$GaudiKernel/ContainedObject.h")))  __attribute__((annotate("$clingAutoload$GaudiPython/Printer.h")))  ContainedObject;
namespace GaudiPython{template <class TYPE> struct __attribute__((annotate("$clingAutoload$GaudiPython/Printer.h")))  Printer;
}
class __attribute__((annotate("$clingAutoload$GaudiKernel/DataObject.h")))  __attribute__((annotate("$clingAutoload$GaudiPython/Helpers.h")))  DataObject;
namespace Tuples{class __attribute__((annotate("$clingAutoload$GaudiAlg/Tuple.h")))  __attribute__((annotate("$clingAutoload$GaudiPython/TupleDecorator.h")))  Tuple;}
template <class PBASE> class __attribute__((annotate("$clingAutoload$GaudiAlg/GaudiTuples.h")))  __attribute__((annotate("$clingAutoload$GaudiPython/TupleDecorator.h")))  GaudiTuples;

class __attribute__((annotate("$clingAutoload$GaudiAlg/ITupleTool.h")))  __attribute__((annotate("$clingAutoload$GaudiPython/TupleDecorator.h")))  ITupleTool;
namespace GaudiPython{class __attribute__((annotate(R"ATTRDUMP(pattern@@@GaudiPython::*Decorator*)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$GaudiPython/TupleDecorator.h")))  TupleDecorator;}
namespace GaudiPython{class __attribute__((annotate(R"ATTRDUMP(pattern@@@GaudiPython::*Decorator*)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$GaudiPython/TupleDecorator.h")))  TupleAlgDecorator;}
namespace GaudiPython{class __attribute__((annotate(R"ATTRDUMP(pattern@@@GaudiPython::*Decorator*)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$GaudiPython/TupleDecorator.h")))  TupleToolDecorator;}
namespace GaudiAlg{class __attribute__((annotate(R"ATTRDUMP(pattern@@@GaudiAlg::*)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$GaudiAlg/Print.h")))  Print;}
namespace GaudiAlg{class __attribute__((annotate(R"ATTRDUMP(pattern@@@GaudiAlg::*)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$GaudiAlg/Print.h")))  Print1D;}
namespace GaudiAlg{class __attribute__((annotate(R"ATTRDUMP(pattern@@@GaudiAlg::*)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$GaudiAlg/Print.h")))  Print2D;}
namespace GaudiAlg{class __attribute__((annotate(R"ATTRDUMP(pattern@@@GaudiAlg::*)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$GaudiAlg/Print.h")))  Print3D;}
namespace GaudiAlg{class __attribute__((annotate(R"ATTRDUMP(pattern@@@GaudiAlg::*)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$GaudiAlg/Print.h")))  Print1DProf;}
namespace GaudiAlg{class __attribute__((annotate(R"ATTRDUMP(pattern@@@GaudiAlg::*)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$GaudiAlg/Print.h")))  Print2DProf;}
namespace GaudiAlg{class __attribute__((annotate(R"ATTRDUMP(pattern@@@GaudiAlg::*)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$GaudiAlg/Print.h")))  PrintTuple;}
namespace GaudiAlg{class __attribute__((annotate(R"ATTRDUMP(pattern@@@GaudiAlg::*)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$GaudiAlg/Print.h")))  PrintStat;}
class __attribute__((annotate("$clingAutoload$GaudiAlg/IErrorTool.h")))  IErrorTool;
class __attribute__((annotate("$clingAutoload$GaudiAlg/IGenericTool.h")))  IGenericTool;
class __attribute__((annotate("$clingAutoload$GaudiAlg/IHistoTool.h")))  IHistoTool;
class __attribute__((annotate("$clingAutoload$GaudiAlg/ISequencerTimerTool.h")))  ISequencerTimerTool;
namespace Gaudi{namespace Utils{class __attribute__((annotate("$clingAutoload$GaudiUtils/Aida2ROOT.h")))  Aida2ROOT;}}
namespace Gaudi{namespace Utils{class __attribute__((annotate("$clingAutoload$GaudiUtils/HistoStats.h")))  HistoStats;}}
namespace Gaudi{namespace Utils{namespace Histos{class __attribute__((annotate("$clingAutoload$GaudiUtils/HistoStrings.h")))  HistoStrings;}}}
namespace Gaudi{class __attribute__((annotate("$clingAutoload$GaudiUtils/IFileCatalog.h")))  IFileCatalog;}
namespace Gaudi{class __attribute__((annotate("$clingAutoload$GaudiUtils/IFileCatalogMgr.h")))  IFileCatalogMgr;}
namespace Gaudi{class __attribute__((annotate("$clingAutoload$GaudiUtils/IIODataManager.h")))  IDataConnection;}
namespace Gaudi{class __attribute__((annotate("$clingAutoload$GaudiUtils/IIODataManager.h")))  IIODataManager;}
namespace __gnu_cxx{struct dummy;}
namespace Histos{typedef GaudiAlg::ID HistoID __attribute__((annotate("$clingAutoload$GaudiAlg/HistoID.h")))  __attribute__((annotate("$clingAutoload$GaudiPython/HistoDecorator.h"))) ;}
namespace GaudiAlg{typedef Histos::HistoID HistoID __attribute__((annotate("$clingAutoload$GaudiAlg/HistoID.h")))  __attribute__((annotate("$clingAutoload$GaudiPython/HistoDecorator.h"))) ;}
namespace Tuples{typedef GaudiAlg::ID TupleID __attribute__((annotate("$clingAutoload$GaudiAlg/TupleID.h")))  __attribute__((annotate("$clingAutoload$GaudiPython/HistoDecorator.h"))) ;}
namespace GaudiAlg{typedef Tuples::TupleID TupleID __attribute__((annotate("$clingAutoload$GaudiAlg/TupleID.h")))  __attribute__((annotate("$clingAutoload$GaudiPython/HistoDecorator.h"))) ;}
)DICTFWDDCLS";
    static const char* payloadCode = R"DICTPAYLOAD(
#line 1 "GaudiPythonDict dictionary payload"
#ifdef _Instantiations
  #undef _Instantiations
#endif

#ifndef G__VECTOR_HAS_CLASS_ITERATOR
  #define G__VECTOR_HAS_CLASS_ITERATOR 1
#endif
#ifndef _Instantiations
  #define _Instantiations GaudiPython_Instantiations
#endif
#ifndef _GNU_SOURCE
  #define _GNU_SOURCE 1
#endif
#ifndef unix
  #define unix 1
#endif
#ifndef f2cFortran
  #define f2cFortran 1
#endif
#ifndef linux
  #define linux 1
#endif
#ifndef GAUDI_V20_COMPAT
  #define GAUDI_V20_COMPAT 1
#endif
#ifndef BOOST_FILESYSTEM_VERSION
  #define BOOST_FILESYSTEM_VERSION 3
#endif
#ifndef BOOST_SPIRIT_USE_PHOENIX_V3
  #define BOOST_SPIRIT_USE_PHOENIX_V3 1
#endif
#ifndef PACKAGE_NAME
  #define PACKAGE_NAME "GaudiPython"
#endif
#ifndef PACKAGE_VERSION
  #define PACKAGE_VERSION "v30r3"
#endif
#ifndef AIDA_FOUND
  #define AIDA_FOUND 1
#endif
#ifndef CLHEP_FOUND
  #define CLHEP_FOUND 1
#endif
#ifndef NDEBUG
  #define NDEBUG 1
#endif

#define _BACKWARD_BACKWARD_WARNING_H
// redefined anyway in features.h by _GNU_SOURCE
#undef _XOPEN_SOURCE
#undef _POSIX_C_SOURCE

// ============================================================================
// Python must always be the first.
#ifndef __APPLE__
#include "Python.h"
#endif // not __APPLE__

#include "GaudiKernel/Algorithm.h"
#include "GaudiKernel/Chrono.h"
#include "GaudiKernel/ChronoEntity.h"
#include "GaudiKernel/HashMap.h"
#include "GaudiKernel/Map.h"
#include "GaudiKernel/MapBase.h"
#include "GaudiKernel/ParticleProperty.h"
#include "GaudiKernel/Property.h"
#include "GaudiKernel/Range.h"
#include "GaudiKernel/SerializeSTL.h"
#include "GaudiKernel/Stat.h"
#include "GaudiKernel/StatEntity.h"
#include "GaudiKernel/StringKey.h"
#include "GaudiKernel/VectorMap.h"

#ifdef _WIN32
#include "GaudiKernel/GaudiHandle.h"
#endif

#ifdef __ICC
// disable icc remark #177: declared but never referenced
#pragma warning( disable : 177 )
// disable icc warning #1125: function "C::X()" is hidden by "Y::X" -- virtual function override intended?
#pragma warning( disable : 1125 )
#endif

// Force visibility of the classes
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wkeyword-macro"
#endif
#define class class GAUDI_API
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef AIDA_FOUND
#ifdef _WIN32
#include "AIDA/IAnnotation.h"
#endif // _WIN32
#include "AIDA/IAxis.h"
#include "AIDA/IHistogram.h"
#include "AIDA/IHistogram1D.h"
#include "AIDA/IHistogram2D.h"
#include "AIDA/IHistogram3D.h"
#include "AIDA/IProfile1D.h"
#include "AIDA/IProfile2D.h"
#endif // AIDA_FOUND
#undef class

#include "GaudiPython/Helpers.h"

#include "GaudiPython/AlgDecorators.h"
#include "GaudiPython/Algorithm.h"
#include "GaudiPython/CallbackStreamBuf.h"
#include "GaudiPython/GaudiPython.h"
#ifdef AIDA_FOUND
#include "GaudiPython/HistoDecorator.h"
#endif // AIDA_FOUND
#include "GaudiPython/Interface.h"
#include "GaudiPython/Printer.h"
#include "GaudiPython/Vector.h"
#ifdef CLHEP_FOUND
#include "GaudiPython/TupleDecorator.h"
#endif // CLHEP_FOUND

#ifdef AIDA_FOUND
#include "GaudiAlg/GaudiHistoAlg.h"
#include "GaudiAlg/GaudiTupleAlg.h"
#include "GaudiAlg/Print.h"
// Added to avoid warnings about inlined functions never implemented.
#include "GaudiAlg/GaudiHistos.icpp"
#endif // AIDA_FOUND
#include "GaudiAlg/GaudiAlgorithm.h"
#include "GaudiAlg/GaudiCommon.h"
#include "GaudiAlg/GaudiHistoID.h"
#include "GaudiAlg/IErrorTool.h"
#include "GaudiAlg/IGenericTool.h"
#include "GaudiAlg/IHistoTool.h"
#include "GaudiAlg/ISequencerTimerTool.h"
#include "GaudiAlg/ITupleTool.h"
#include "GaudiAlg/Tuple.h"

#ifdef AIDA_FOUND
#include "GaudiUtils/Aida2ROOT.h"
#include "GaudiUtils/HistoDump.h"
#include "GaudiUtils/HistoStats.h"
#include "GaudiUtils/HistoStrings.h"
#endif // AIDA_FOUND
#include "GaudiUtils/IFileCatalog.h"
#include "GaudiUtils/IFileCatalogMgr.h"
#include "GaudiUtils/IIODataManager.h"
#include "GaudiUtils/QuasiRandom.h"

#include <iostream>
#include <istream>
#include <sstream>

template class std::basic_stringstream<char>;

// needed to find operator<< implemented in GaudiUtils.
using namespace GaudiUtils;

namespace GaudiPython
{

  template <class TYPE>
  struct _Property {
    TYPE                   m_type;
    Gaudi::Property<TYPE>  m_prop;
    Gaudi::Property<TYPE&> m_ref;
    // constructor
    _Property() : m_type(), m_prop(), m_ref( "", m_type ) {}
    //
  };

  //--- Template instantiations
  struct __Instantiations {
    std::vector<Gaudi::Details::PropertyBase*>       i0;
    std::vector<const Gaudi::Details::PropertyBase*> i00;
    std::vector<IRegistry*>                          i00000;

    std::allocator<IRegistry*>  a0;
    std::allocator<IAlgorithm*> a1;
    std::allocator<IService*>   a2;

    std::list<IAlgorithm*> i01;
    std::list<IService*>   i02;

    std::vector<IService*>    i05_1;
    std::vector<IAlgTool*>    i05_2;
    std::vector<StatEntity*>  i05_3;
    std::vector<GaudiAlg::ID> i05_4;
#ifdef AIDA_FOUND
    std::vector<AIDA::IHistogram1D*> i05_5;
    std::vector<AIDA::IHistogram2D*> i05_6;
    std::vector<AIDA::IHistogram3D*> i05_7;
    std::vector<AIDA::IProfile1D*>   i05_8;
    std::vector<AIDA::IProfile2D*>   i05_9;
#endif // AIDA_FOUND

    // Gaudi::IIODataManager              *gu_i1000;

    GaudiUtils::VectorMap<int, double> i034;

    GaudiPython::PyAlg<GaudiAlgorithm> _alg0;
#ifdef AIDA_FOUND
    GaudiPython::PyAlg<GaudiHistoAlg> _alg1;
    GaudiPython::PyAlg<GaudiTupleAlg> _alg2;
#endif // AIDA_FOUND

    GaudiPython::Matrix              _mtrx;
    GaudiPython::Vector              _vctr;
    std::vector<std::vector<double>> _vct1;

    // primitives:
    _Property<bool>               pp_01;
    _Property<char>               pp_02;
    _Property<signed char>        pp_03;
    _Property<unsigned char>      pp_04;
    _Property<short>              pp_05;
    _Property<unsigned short>     pp_06;
    _Property<int>                pp_07;
    _Property<unsigned int>       pp_08;
    _Property<long>               pp_09;
    _Property<unsigned long>      pp_10;
    _Property<long long>          pp_11;
    _Property<unsigned long long> pp_12;
    _Property<float>              pp_13;
    _Property<double>             pp_14;
    _Property<long double>        pp_15;
    _Property<std::string>        pp_16;

    // vectors of primitives
    _Property<std::vector<bool>>               vp_01;
    _Property<std::vector<char>>               vp_02;
    _Property<std::vector<signed char>>        vp_03;
    _Property<std::vector<unsigned char>>      vp_04;
    _Property<std::vector<short>>              vp_05;
    _Property<std::vector<unsigned short>>     vp_06;
    _Property<std::vector<int>>                vp_07;
    _Property<std::vector<unsigned int>>       vp_08;
    _Property<std::vector<long>>               vp_09;
    _Property<std::vector<unsigned long>>      vp_10;
    _Property<std::vector<long long>>          vp_11;
    _Property<std::vector<unsigned long long>> vp_12;
    _Property<std::vector<float>>              vp_13;
    _Property<std::vector<double>>             vp_14;
    _Property<std::vector<long double>>        vp_15;
    _Property<std::vector<std::string>>        vp_16;

    // some extended types
    _Property<std::pair<int, int>>                    ep_01;
    _Property<std::pair<double, double>>              ep_02;
    _Property<std::vector<std::pair<double, double>>> ep_04;
    _Property<std::vector<std::vector<std::string>>> ep_05;
    _Property<std::vector<std::vector<double>>>      ep_06;
    _Property<std::map<int, double>>                           ep_07;
    _Property<std::map<std::string, std::string>>              ep_08;
    _Property<std::map<std::string, int>>                      ep_09;
    _Property<std::map<std::string, double>>                   ep_10;
    _Property<std::map<std::string, std::vector<std::string>>> ep_11;
    _Property<std::map<std::string, std::vector<int>>>         ep_12;
    _Property<std::map<std::string, std::vector<double>>>      ep_13;

    __Instantiations();
    ~__Instantiations();
  };

} // end of namespace GaudiPython

namespace __gnu_cxx
{
  struct dummy {
  };
} // hack to please CINT

#ifdef _WIN32
#pragma warning( disable : 4345 )
#pragma warning( disable : 4624 )
#endif

#ifdef __ICC
// disable icc warning #191: type qualifier is meaningless on cast type
// ... a lot of noise produced by the dictionary
#pragma warning( disable : 191 )
#endif

// ============================================================================
// The END
// ============================================================================

#undef  _BACKWARD_BACKWARD_WARNING_H
)DICTPAYLOAD";
    static const char* classesHeaders[]={
"", payloadCode, "@",
"AIDA::IAxis", payloadCode, "@",
"AIDA::IAxis::(anonymous)", payloadCode, "@",
"AIDA::IBaseHistogram", payloadCode, "@",
"AIDA::IHistogram", payloadCode, "@",
"AIDA::IHistogram1D", payloadCode, "@",
"AIDA::IHistogram2D", payloadCode, "@",
"AIDA::IHistogram3D", payloadCode, "@",
"AIDA::IProfile", payloadCode, "@",
"AIDA::IProfile1D", payloadCode, "@",
"AIDA::IProfile2D", payloadCode, "@",
"Chrono", payloadCode, "@",
"ChronoEntity", payloadCode, "@",
"Gaudi::IDataConnection", payloadCode, "@",
"Gaudi::IFileCatalog", payloadCode, "@",
"Gaudi::IFileCatalogMgr", payloadCode, "@",
"Gaudi::IIODataManager", payloadCode, "@",
"Gaudi::RangeBase_", payloadCode, "@",
"Gaudi::StringKey", payloadCode, "@",
"Gaudi::Utils::Aida2ROOT", payloadCode, "@",
"Gaudi::Utils::HistoStats", payloadCode, "@",
"Gaudi::Utils::Histos::Formats::Format", payloadCode, "@",
"Gaudi::Utils::Histos::Formats::format", payloadCode, "@",
"Gaudi::Utils::Histos::Formats::header", payloadCode, "@",
"Gaudi::Utils::Histos::HistoStrings", payloadCode, "@",
"Gaudi::Utils::Histos::Table", payloadCode, "@",
"Gaudi::Utils::Histos::format", payloadCode, "@",
"Gaudi::Utils::Histos::histoDump", payloadCode, "@",
"Gaudi::Utils::Histos::path", payloadCode, "@",
"Gaudi::Utils::MapBase", payloadCode, "@",
"Gaudi::Utils::QuasiRandom::mix", payloadCode, "@",
"Gaudi::Utils::QuasiRandom::mix32", payloadCode, "@",
"Gaudi::Utils::QuasiRandom::mix64", payloadCode, "@",
"Gaudi::Utils::QuasiRandom::mixString", payloadCode, "@",
"Gaudi::Utils::hasProperty", payloadCode, "@",
"GaudiAlg::HistoID", payloadCode, "@",
"GaudiAlg::ID", payloadCode, "@",
"GaudiAlg::Print", payloadCode, "@",
"GaudiAlg::Print1D", payloadCode, "@",
"GaudiAlg::Print1DProf", payloadCode, "@",
"GaudiAlg::Print2D", payloadCode, "@",
"GaudiAlg::Print2DProf", payloadCode, "@",
"GaudiAlg::Print3D", payloadCode, "@",
"GaudiAlg::PrintStat", payloadCode, "@",
"GaudiAlg::PrintTuple", payloadCode, "@",
"GaudiAlg::TupleID", payloadCode, "@",
"GaudiAlgorithm", payloadCode, "@",
"GaudiCommon<AlgTool>", payloadCode, "@",
"GaudiCommon<Algorithm>", payloadCode, "@",
"GaudiHistos<GaudiAlgorithm>", payloadCode, "@",
"GaudiHistos<GaudiTool>", payloadCode, "@",
"GaudiPython::AlgDecorator", payloadCode, "@",
"GaudiPython::CallbackStreamBuf", payloadCode, "@",
"GaudiPython::Helper", payloadCode, "@",
"GaudiPython::HistoDecorator", payloadCode, "@",
"GaudiPython::Printer<ContainedObject>", payloadCode, "@",
"GaudiPython::Printer<DataObject>", payloadCode, "@",
"GaudiPython::PyAlg<GaudiAlgorithm>", payloadCode, "@",
"GaudiPython::PyAlg<GaudiHistoAlg>", payloadCode, "@",
"GaudiPython::PyAlg<GaudiTupleAlg>", payloadCode, "@",
"GaudiPython::PyAlgorithm", payloadCode, "@",
"GaudiPython::TupleAlgDecorator", payloadCode, "@",
"GaudiPython::TupleDecorator", payloadCode, "@",
"GaudiPython::TupleToolDecorator", payloadCode, "@",
"GaudiTuples<GaudiHistoAlg>", payloadCode, "@",
"IErrorTool", payloadCode, "@",
"IGenericTool", payloadCode, "@",
"IHistoTool", payloadCode, "@",
"ISequencerTimerTool", payloadCode, "@",
"ITupleTool", payloadCode, "@",
"ParticleProperty", payloadCode, "@",
"Stat", payloadCode, "@",
"StatEntity", payloadCode, "@",
"Tuples::Tuple", payloadCode, "@",
"_Bit_reference", "@",
"__gnu_cxx::dummy", payloadCode, "@",
"std::ostream", payloadCode, "@",
nullptr};

    static bool isInitialized = false;
    if (!isInitialized) {
      TROOT::RegisterModule("GaudiPythonDict",
        headers, includePaths, payloadCode, fwdDeclCode,
        TriggerDictionaryInitialization_GaudiPythonDict_Impl, {}, classesHeaders);
      isInitialized = true;
    }
  }
  static struct DictInit {
    DictInit() {
      TriggerDictionaryInitialization_GaudiPythonDict_Impl();
    }
  } __TheDictionaryInitializer;
}
void TriggerDictionaryInitialization_GaudiPythonDict() {
  TriggerDictionaryInitialization_GaudiPythonDict_Impl();
}