// Do NOT change. Changes will be lost next time file is generated #define R__DICTIONARY_FILENAME dIkm3netdIaanetdIbuilddIdIJppGraddOdict #define R__NO_DEPRECATION /*******************************************************************/ #include #include #include #include #include #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 #include "TCollectionProxyInfo.h" /*******************************************************************/ #include "TDataMember.h" // The generated code does not explicitly qualifies STL entities namespace std {} using namespace std; // Header files passed as explicit arguments #include "JppGrad.hh" // Header files passed via #pragma extra_include namespace ROOT { static TClass *JppGrad_Dictionary(); static void JppGrad_TClassManip(TClass*); static void *new_JppGrad(void *p = 0); static void *newArray_JppGrad(Long_t size, void *p); static void delete_JppGrad(void *p); static void deleteArray_JppGrad(void *p); static void destruct_JppGrad(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const ::JppGrad*) { ::JppGrad *ptr = 0; static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::JppGrad)); static ::ROOT::TGenericClassInfo instance("JppGrad", "JppGrad.hh", 87, typeid(::JppGrad), ::ROOT::Internal::DefineBehavior(ptr, ptr), &JppGrad_Dictionary, isa_proxy, 4, sizeof(::JppGrad) ); instance.SetNew(&new_JppGrad); instance.SetNewArray(&newArray_JppGrad); instance.SetDelete(&delete_JppGrad); instance.SetDeleteArray(&deleteArray_JppGrad); instance.SetDestructor(&destruct_JppGrad); return &instance; } TGenericClassInfo *GenerateInitInstance(const ::JppGrad*) { return GenerateInitInstanceLocal((::JppGrad*)0); } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::JppGrad*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init)); // Dictionary for non-ClassDef classes static TClass *JppGrad_Dictionary() { TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::JppGrad*)0x0)->GetClass(); JppGrad_TClassManip(theClass); return theClass; } static void JppGrad_TClassManip(TClass* theClass){ theClass->CreateAttributeMap(); TDictAttributeMap* attrMap( theClass->GetAttributeMap() ); attrMap->AddProperty("file_name","JppGrad.hh"); } } // end of namespace ROOT namespace ROOT { // Wrappers around operator new static void *new_JppGrad(void *p) { return p ? new(p) ::JppGrad : new ::JppGrad; } static void *newArray_JppGrad(Long_t nElements, void *p) { return p ? new(p) ::JppGrad[nElements] : new ::JppGrad[nElements]; } // Wrapper around operator delete static void delete_JppGrad(void *p) { delete ((::JppGrad*)p); } static void deleteArray_JppGrad(void *p) { delete [] ((::JppGrad*)p); } static void destruct_JppGrad(void *p) { typedef ::JppGrad current_t; ((current_t*)p)->~current_t(); } } // end of namespace ROOT for class ::JppGrad namespace ROOT { static TClass *vectorlEvectorlEvectorlEdoublegRsPgRsPgR_Dictionary(); static void vectorlEvectorlEvectorlEdoublegRsPgRsPgR_TClassManip(TClass*); static void *new_vectorlEvectorlEvectorlEdoublegRsPgRsPgR(void *p = 0); static void *newArray_vectorlEvectorlEvectorlEdoublegRsPgRsPgR(Long_t size, void *p); static void delete_vectorlEvectorlEvectorlEdoublegRsPgRsPgR(void *p); static void deleteArray_vectorlEvectorlEvectorlEdoublegRsPgRsPgR(void *p); static void destruct_vectorlEvectorlEvectorlEdoublegRsPgRsPgR(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const vector > >*) { vector > > *ptr = 0; static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(vector > >)); static ::ROOT::TGenericClassInfo instance("vector > >", -2, "vector", 210, typeid(vector > >), ::ROOT::Internal::DefineBehavior(ptr, ptr), &vectorlEvectorlEvectorlEdoublegRsPgRsPgR_Dictionary, isa_proxy, 0, sizeof(vector > >) ); instance.SetNew(&new_vectorlEvectorlEvectorlEdoublegRsPgRsPgR); instance.SetNewArray(&newArray_vectorlEvectorlEvectorlEdoublegRsPgRsPgR); instance.SetDelete(&delete_vectorlEvectorlEvectorlEdoublegRsPgRsPgR); instance.SetDeleteArray(&deleteArray_vectorlEvectorlEvectorlEdoublegRsPgRsPgR); instance.SetDestructor(&destruct_vectorlEvectorlEvectorlEdoublegRsPgRsPgR); instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::Pushback< vector > > >())); ::ROOT::AddClassAlternate("vector > >","std::vector >, std::allocator > > >, std::allocator >, std::allocator > > > > >"); return &instance; } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const vector > >*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init)); // Dictionary for non-ClassDef classes static TClass *vectorlEvectorlEvectorlEdoublegRsPgRsPgR_Dictionary() { TClass* theClass =::ROOT::GenerateInitInstanceLocal((const vector > >*)0x0)->GetClass(); vectorlEvectorlEvectorlEdoublegRsPgRsPgR_TClassManip(theClass); return theClass; } static void vectorlEvectorlEvectorlEdoublegRsPgRsPgR_TClassManip(TClass* ){ } } // end of namespace ROOT namespace ROOT { // Wrappers around operator new static void *new_vectorlEvectorlEvectorlEdoublegRsPgRsPgR(void *p) { return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) vector > > : new vector > >; } static void *newArray_vectorlEvectorlEvectorlEdoublegRsPgRsPgR(Long_t nElements, void *p) { return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) vector > >[nElements] : new vector > >[nElements]; } // Wrapper around operator delete static void delete_vectorlEvectorlEvectorlEdoublegRsPgRsPgR(void *p) { delete ((vector > >*)p); } static void deleteArray_vectorlEvectorlEvectorlEdoublegRsPgRsPgR(void *p) { delete [] ((vector > >*)p); } static void destruct_vectorlEvectorlEvectorlEdoublegRsPgRsPgR(void *p) { typedef vector > > current_t; ((current_t*)p)->~current_t(); } } // end of namespace ROOT for class vector > > 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 > *ptr = 0; static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(vector >)); static ::ROOT::TGenericClassInfo instance("vector >", -2, "vector", 210, typeid(vector >), ::ROOT::Internal::DefineBehavior(ptr, ptr), &vectorlEvectorlEdoublegRsPgR_Dictionary, isa_proxy, 0, sizeof(vector >) ); 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 > >())); ::ROOT::AddClassAlternate("vector >","std::vector >, std::allocator > > >"); return &instance; } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const vector >*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init)); // Dictionary for non-ClassDef classes static TClass *vectorlEvectorlEdoublegRsPgR_Dictionary() { TClass* theClass =::ROOT::GenerateInitInstanceLocal((const vector >*)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 > : new vector >; } static void *newArray_vectorlEvectorlEdoublegRsPgR(Long_t nElements, void *p) { return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) vector >[nElements] : new vector >[nElements]; } // Wrapper around operator delete static void delete_vectorlEvectorlEdoublegRsPgR(void *p) { delete ((vector >*)p); } static void deleteArray_vectorlEvectorlEdoublegRsPgR(void *p) { delete [] ((vector >*)p); } static void destruct_vectorlEvectorlEdoublegRsPgR(void *p) { typedef vector > current_t; ((current_t*)p)->~current_t(); } } // end of namespace ROOT for class vector > 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*) { vector *ptr = 0; static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(vector)); static ::ROOT::TGenericClassInfo instance("vector", -2, "vector", 210, typeid(vector), ::ROOT::Internal::DefineBehavior(ptr, ptr), &vectorlEdoublegR_Dictionary, isa_proxy, 0, sizeof(vector) ); 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 >())); ::ROOT::AddClassAlternate("vector","std::vector >"); return &instance; } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const vector*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init)); // Dictionary for non-ClassDef classes static TClass *vectorlEdoublegR_Dictionary() { TClass* theClass =::ROOT::GenerateInitInstanceLocal((const vector*)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 : new vector; } static void *newArray_vectorlEdoublegR(Long_t nElements, void *p) { return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) vector[nElements] : new vector[nElements]; } // Wrapper around operator delete static void delete_vectorlEdoublegR(void *p) { delete ((vector*)p); } static void deleteArray_vectorlEdoublegR(void *p) { delete [] ((vector*)p); } static void destruct_vectorlEdoublegR(void *p) { typedef vector current_t; ((current_t*)p)->~current_t(); } } // end of namespace ROOT for class vector namespace ROOT { static TClass *vectorlETrkgR_Dictionary(); static void vectorlETrkgR_TClassManip(TClass*); static void *new_vectorlETrkgR(void *p = 0); static void *newArray_vectorlETrkgR(Long_t size, void *p); static void delete_vectorlETrkgR(void *p); static void deleteArray_vectorlETrkgR(void *p); static void destruct_vectorlETrkgR(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const vector*) { vector *ptr = 0; static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(vector)); static ::ROOT::TGenericClassInfo instance("vector", -2, "vector", 210, typeid(vector), ::ROOT::Internal::DefineBehavior(ptr, ptr), &vectorlETrkgR_Dictionary, isa_proxy, 0, sizeof(vector) ); instance.SetNew(&new_vectorlETrkgR); instance.SetNewArray(&newArray_vectorlETrkgR); instance.SetDelete(&delete_vectorlETrkgR); instance.SetDeleteArray(&deleteArray_vectorlETrkgR); instance.SetDestructor(&destruct_vectorlETrkgR); instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::Pushback< vector >())); ::ROOT::AddClassAlternate("vector","std::vector >"); return &instance; } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const vector*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init)); // Dictionary for non-ClassDef classes static TClass *vectorlETrkgR_Dictionary() { TClass* theClass =::ROOT::GenerateInitInstanceLocal((const vector*)0x0)->GetClass(); vectorlETrkgR_TClassManip(theClass); return theClass; } static void vectorlETrkgR_TClassManip(TClass* ){ } } // end of namespace ROOT namespace ROOT { // Wrappers around operator new static void *new_vectorlETrkgR(void *p) { return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) vector : new vector; } static void *newArray_vectorlETrkgR(Long_t nElements, void *p) { return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) vector[nElements] : new vector[nElements]; } // Wrapper around operator delete static void delete_vectorlETrkgR(void *p) { delete ((vector*)p); } static void deleteArray_vectorlETrkgR(void *p) { delete [] ((vector*)p); } static void destruct_vectorlETrkgR(void *p) { typedef vector current_t; ((current_t*)p)->~current_t(); } } // end of namespace ROOT for class vector namespace ROOT { static TClass *vectorlEParamstgR_Dictionary(); static void vectorlEParamstgR_TClassManip(TClass*); static void *new_vectorlEParamstgR(void *p = 0); static void *newArray_vectorlEParamstgR(Long_t size, void *p); static void delete_vectorlEParamstgR(void *p); static void deleteArray_vectorlEParamstgR(void *p); static void destruct_vectorlEParamstgR(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const vector*) { vector *ptr = 0; static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(vector)); static ::ROOT::TGenericClassInfo instance("vector", -2, "vector", 210, typeid(vector), ::ROOT::Internal::DefineBehavior(ptr, ptr), &vectorlEParamstgR_Dictionary, isa_proxy, 0, sizeof(vector) ); instance.SetNew(&new_vectorlEParamstgR); instance.SetNewArray(&newArray_vectorlEParamstgR); instance.SetDelete(&delete_vectorlEParamstgR); instance.SetDeleteArray(&deleteArray_vectorlEParamstgR); instance.SetDestructor(&destruct_vectorlEParamstgR); instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::Pushback< vector >())); ::ROOT::AddClassAlternate("vector","std::vector >"); return &instance; } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const vector*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init)); // Dictionary for non-ClassDef classes static TClass *vectorlEParamstgR_Dictionary() { TClass* theClass =::ROOT::GenerateInitInstanceLocal((const vector*)0x0)->GetClass(); vectorlEParamstgR_TClassManip(theClass); return theClass; } static void vectorlEParamstgR_TClassManip(TClass* ){ } } // end of namespace ROOT namespace ROOT { // Wrappers around operator new static void *new_vectorlEParamstgR(void *p) { return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) vector : new vector; } static void *newArray_vectorlEParamstgR(Long_t nElements, void *p) { return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) vector[nElements] : new vector[nElements]; } // Wrapper around operator delete static void delete_vectorlEParamstgR(void *p) { delete ((vector*)p); } static void deleteArray_vectorlEParamstgR(void *p) { delete [] ((vector*)p); } static void destruct_vectorlEParamstgR(void *p) { typedef vector current_t; ((current_t*)p)->~current_t(); } } // end of namespace ROOT for class vector namespace ROOT { static TClass *vectorlEParamsgR_Dictionary(); static void vectorlEParamsgR_TClassManip(TClass*); static void *new_vectorlEParamsgR(void *p = 0); static void *newArray_vectorlEParamsgR(Long_t size, void *p); static void delete_vectorlEParamsgR(void *p); static void deleteArray_vectorlEParamsgR(void *p); static void destruct_vectorlEParamsgR(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const vector*) { vector *ptr = 0; static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(vector)); static ::ROOT::TGenericClassInfo instance("vector", -2, "vector", 210, typeid(vector), ::ROOT::Internal::DefineBehavior(ptr, ptr), &vectorlEParamsgR_Dictionary, isa_proxy, 0, sizeof(vector) ); instance.SetNew(&new_vectorlEParamsgR); instance.SetNewArray(&newArray_vectorlEParamsgR); instance.SetDelete(&delete_vectorlEParamsgR); instance.SetDeleteArray(&deleteArray_vectorlEParamsgR); instance.SetDestructor(&destruct_vectorlEParamsgR); instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::Pushback< vector >())); ::ROOT::AddClassAlternate("vector","std::vector >"); return &instance; } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const vector*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init)); // Dictionary for non-ClassDef classes static TClass *vectorlEParamsgR_Dictionary() { TClass* theClass =::ROOT::GenerateInitInstanceLocal((const vector*)0x0)->GetClass(); vectorlEParamsgR_TClassManip(theClass); return theClass; } static void vectorlEParamsgR_TClassManip(TClass* ){ } } // end of namespace ROOT namespace ROOT { // Wrappers around operator new static void *new_vectorlEParamsgR(void *p) { return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) vector : new vector; } static void *newArray_vectorlEParamsgR(Long_t nElements, void *p) { return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) vector[nElements] : new vector[nElements]; } // Wrapper around operator delete static void delete_vectorlEParamsgR(void *p) { delete ((vector*)p); } static void deleteArray_vectorlEParamsgR(void *p) { delete [] ((vector*)p); } static void destruct_vectorlEParamsgR(void *p) { typedef vector current_t; ((current_t*)p)->~current_t(); } } // end of namespace ROOT for class vector namespace ROOT { static TClass *vectorlEJTOOLScLcLJResultDerivativelEJTOOLScLcLJResultDerivativelEJTOOLScLcLJResultDerivativelEJTOOLScLcLJResultDerivativelEdoublegRsPgRsPgRsPgRsPgR_Dictionary(); static void vectorlEJTOOLScLcLJResultDerivativelEJTOOLScLcLJResultDerivativelEJTOOLScLcLJResultDerivativelEJTOOLScLcLJResultDerivativelEdoublegRsPgRsPgRsPgRsPgR_TClassManip(TClass*); static void *new_vectorlEJTOOLScLcLJResultDerivativelEJTOOLScLcLJResultDerivativelEJTOOLScLcLJResultDerivativelEJTOOLScLcLJResultDerivativelEdoublegRsPgRsPgRsPgRsPgR(void *p = 0); static void *newArray_vectorlEJTOOLScLcLJResultDerivativelEJTOOLScLcLJResultDerivativelEJTOOLScLcLJResultDerivativelEJTOOLScLcLJResultDerivativelEdoublegRsPgRsPgRsPgRsPgR(Long_t size, void *p); static void delete_vectorlEJTOOLScLcLJResultDerivativelEJTOOLScLcLJResultDerivativelEJTOOLScLcLJResultDerivativelEJTOOLScLcLJResultDerivativelEdoublegRsPgRsPgRsPgRsPgR(void *p); static void deleteArray_vectorlEJTOOLScLcLJResultDerivativelEJTOOLScLcLJResultDerivativelEJTOOLScLcLJResultDerivativelEJTOOLScLcLJResultDerivativelEdoublegRsPgRsPgRsPgRsPgR(void *p); static void destruct_vectorlEJTOOLScLcLJResultDerivativelEJTOOLScLcLJResultDerivativelEJTOOLScLcLJResultDerivativelEJTOOLScLcLJResultDerivativelEdoublegRsPgRsPgRsPgRsPgR(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const vector > > > >*) { vector > > > > *ptr = 0; static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(vector > > > >)); static ::ROOT::TGenericClassInfo instance("vector > > > >", -2, "vector", 210, typeid(vector > > > >), ::ROOT::Internal::DefineBehavior(ptr, ptr), &vectorlEJTOOLScLcLJResultDerivativelEJTOOLScLcLJResultDerivativelEJTOOLScLcLJResultDerivativelEJTOOLScLcLJResultDerivativelEdoublegRsPgRsPgRsPgRsPgR_Dictionary, isa_proxy, 0, sizeof(vector > > > >) ); instance.SetNew(&new_vectorlEJTOOLScLcLJResultDerivativelEJTOOLScLcLJResultDerivativelEJTOOLScLcLJResultDerivativelEJTOOLScLcLJResultDerivativelEdoublegRsPgRsPgRsPgRsPgR); instance.SetNewArray(&newArray_vectorlEJTOOLScLcLJResultDerivativelEJTOOLScLcLJResultDerivativelEJTOOLScLcLJResultDerivativelEJTOOLScLcLJResultDerivativelEdoublegRsPgRsPgRsPgRsPgR); instance.SetDelete(&delete_vectorlEJTOOLScLcLJResultDerivativelEJTOOLScLcLJResultDerivativelEJTOOLScLcLJResultDerivativelEJTOOLScLcLJResultDerivativelEdoublegRsPgRsPgRsPgRsPgR); instance.SetDeleteArray(&deleteArray_vectorlEJTOOLScLcLJResultDerivativelEJTOOLScLcLJResultDerivativelEJTOOLScLcLJResultDerivativelEJTOOLScLcLJResultDerivativelEdoublegRsPgRsPgRsPgRsPgR); instance.SetDestructor(&destruct_vectorlEJTOOLScLcLJResultDerivativelEJTOOLScLcLJResultDerivativelEJTOOLScLcLJResultDerivativelEJTOOLScLcLJResultDerivativelEdoublegRsPgRsPgRsPgRsPgR); instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::Pushback< vector > > > > >())); ::ROOT::AddClassAlternate("vector > > > >","std::vector > > >, std::allocator > > > > >"); return &instance; } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const vector > > > >*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init)); // Dictionary for non-ClassDef classes static TClass *vectorlEJTOOLScLcLJResultDerivativelEJTOOLScLcLJResultDerivativelEJTOOLScLcLJResultDerivativelEJTOOLScLcLJResultDerivativelEdoublegRsPgRsPgRsPgRsPgR_Dictionary() { TClass* theClass =::ROOT::GenerateInitInstanceLocal((const vector > > > >*)0x0)->GetClass(); vectorlEJTOOLScLcLJResultDerivativelEJTOOLScLcLJResultDerivativelEJTOOLScLcLJResultDerivativelEJTOOLScLcLJResultDerivativelEdoublegRsPgRsPgRsPgRsPgR_TClassManip(theClass); return theClass; } static void vectorlEJTOOLScLcLJResultDerivativelEJTOOLScLcLJResultDerivativelEJTOOLScLcLJResultDerivativelEJTOOLScLcLJResultDerivativelEdoublegRsPgRsPgRsPgRsPgR_TClassManip(TClass* ){ } } // end of namespace ROOT namespace ROOT { // Wrappers around operator new static void *new_vectorlEJTOOLScLcLJResultDerivativelEJTOOLScLcLJResultDerivativelEJTOOLScLcLJResultDerivativelEJTOOLScLcLJResultDerivativelEdoublegRsPgRsPgRsPgRsPgR(void *p) { return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) vector > > > > : new vector > > > >; } static void *newArray_vectorlEJTOOLScLcLJResultDerivativelEJTOOLScLcLJResultDerivativelEJTOOLScLcLJResultDerivativelEJTOOLScLcLJResultDerivativelEdoublegRsPgRsPgRsPgRsPgR(Long_t nElements, void *p) { return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) vector > > > >[nElements] : new vector > > > >[nElements]; } // Wrapper around operator delete static void delete_vectorlEJTOOLScLcLJResultDerivativelEJTOOLScLcLJResultDerivativelEJTOOLScLcLJResultDerivativelEJTOOLScLcLJResultDerivativelEdoublegRsPgRsPgRsPgRsPgR(void *p) { delete ((vector > > > >*)p); } static void deleteArray_vectorlEJTOOLScLcLJResultDerivativelEJTOOLScLcLJResultDerivativelEJTOOLScLcLJResultDerivativelEJTOOLScLcLJResultDerivativelEdoublegRsPgRsPgRsPgRsPgR(void *p) { delete [] ((vector > > > >*)p); } static void destruct_vectorlEJTOOLScLcLJResultDerivativelEJTOOLScLcLJResultDerivativelEJTOOLScLcLJResultDerivativelEJTOOLScLcLJResultDerivativelEdoublegRsPgRsPgRsPgRsPgR(void *p) { typedef vector > > > > current_t; ((current_t*)p)->~current_t(); } } // end of namespace ROOT for class vector > > > > namespace ROOT { static TClass *vectorlEJTOOLScLcLJResultDerivativelEJTOOLScLcLJResultDerivativelEJTOOLScLcLJResultDerivativelEJTOOLScLcLJResultDerivativelEJTOOLScLcLJResultPDFlEdoublegRsPgRsPgRsPgRsPgRsPgR_Dictionary(); static void vectorlEJTOOLScLcLJResultDerivativelEJTOOLScLcLJResultDerivativelEJTOOLScLcLJResultDerivativelEJTOOLScLcLJResultDerivativelEJTOOLScLcLJResultPDFlEdoublegRsPgRsPgRsPgRsPgRsPgR_TClassManip(TClass*); static void *new_vectorlEJTOOLScLcLJResultDerivativelEJTOOLScLcLJResultDerivativelEJTOOLScLcLJResultDerivativelEJTOOLScLcLJResultDerivativelEJTOOLScLcLJResultPDFlEdoublegRsPgRsPgRsPgRsPgRsPgR(void *p = 0); static void *newArray_vectorlEJTOOLScLcLJResultDerivativelEJTOOLScLcLJResultDerivativelEJTOOLScLcLJResultDerivativelEJTOOLScLcLJResultDerivativelEJTOOLScLcLJResultPDFlEdoublegRsPgRsPgRsPgRsPgRsPgR(Long_t size, void *p); static void delete_vectorlEJTOOLScLcLJResultDerivativelEJTOOLScLcLJResultDerivativelEJTOOLScLcLJResultDerivativelEJTOOLScLcLJResultDerivativelEJTOOLScLcLJResultPDFlEdoublegRsPgRsPgRsPgRsPgRsPgR(void *p); static void deleteArray_vectorlEJTOOLScLcLJResultDerivativelEJTOOLScLcLJResultDerivativelEJTOOLScLcLJResultDerivativelEJTOOLScLcLJResultDerivativelEJTOOLScLcLJResultPDFlEdoublegRsPgRsPgRsPgRsPgRsPgR(void *p); static void destruct_vectorlEJTOOLScLcLJResultDerivativelEJTOOLScLcLJResultDerivativelEJTOOLScLcLJResultDerivativelEJTOOLScLcLJResultDerivativelEJTOOLScLcLJResultPDFlEdoublegRsPgRsPgRsPgRsPgRsPgR(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const vector > > > > >*) { vector > > > > > *ptr = 0; static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(vector > > > > >)); static ::ROOT::TGenericClassInfo instance("vector > > > > >", -2, "vector", 210, typeid(vector > > > > >), ::ROOT::Internal::DefineBehavior(ptr, ptr), &vectorlEJTOOLScLcLJResultDerivativelEJTOOLScLcLJResultDerivativelEJTOOLScLcLJResultDerivativelEJTOOLScLcLJResultDerivativelEJTOOLScLcLJResultPDFlEdoublegRsPgRsPgRsPgRsPgRsPgR_Dictionary, isa_proxy, 0, sizeof(vector > > > > >) ); instance.SetNew(&new_vectorlEJTOOLScLcLJResultDerivativelEJTOOLScLcLJResultDerivativelEJTOOLScLcLJResultDerivativelEJTOOLScLcLJResultDerivativelEJTOOLScLcLJResultPDFlEdoublegRsPgRsPgRsPgRsPgRsPgR); instance.SetNewArray(&newArray_vectorlEJTOOLScLcLJResultDerivativelEJTOOLScLcLJResultDerivativelEJTOOLScLcLJResultDerivativelEJTOOLScLcLJResultDerivativelEJTOOLScLcLJResultPDFlEdoublegRsPgRsPgRsPgRsPgRsPgR); instance.SetDelete(&delete_vectorlEJTOOLScLcLJResultDerivativelEJTOOLScLcLJResultDerivativelEJTOOLScLcLJResultDerivativelEJTOOLScLcLJResultDerivativelEJTOOLScLcLJResultPDFlEdoublegRsPgRsPgRsPgRsPgRsPgR); instance.SetDeleteArray(&deleteArray_vectorlEJTOOLScLcLJResultDerivativelEJTOOLScLcLJResultDerivativelEJTOOLScLcLJResultDerivativelEJTOOLScLcLJResultDerivativelEJTOOLScLcLJResultPDFlEdoublegRsPgRsPgRsPgRsPgRsPgR); instance.SetDestructor(&destruct_vectorlEJTOOLScLcLJResultDerivativelEJTOOLScLcLJResultDerivativelEJTOOLScLcLJResultDerivativelEJTOOLScLcLJResultDerivativelEJTOOLScLcLJResultPDFlEdoublegRsPgRsPgRsPgRsPgRsPgR); instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::Pushback< vector > > > > > >())); ::ROOT::AddClassAlternate("vector > > > > >","std::vector > > > >, std::allocator > > > > > >"); return &instance; } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const vector > > > > >*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init)); // Dictionary for non-ClassDef classes static TClass *vectorlEJTOOLScLcLJResultDerivativelEJTOOLScLcLJResultDerivativelEJTOOLScLcLJResultDerivativelEJTOOLScLcLJResultDerivativelEJTOOLScLcLJResultPDFlEdoublegRsPgRsPgRsPgRsPgRsPgR_Dictionary() { TClass* theClass =::ROOT::GenerateInitInstanceLocal((const vector > > > > >*)0x0)->GetClass(); vectorlEJTOOLScLcLJResultDerivativelEJTOOLScLcLJResultDerivativelEJTOOLScLcLJResultDerivativelEJTOOLScLcLJResultDerivativelEJTOOLScLcLJResultPDFlEdoublegRsPgRsPgRsPgRsPgRsPgR_TClassManip(theClass); return theClass; } static void vectorlEJTOOLScLcLJResultDerivativelEJTOOLScLcLJResultDerivativelEJTOOLScLcLJResultDerivativelEJTOOLScLcLJResultDerivativelEJTOOLScLcLJResultPDFlEdoublegRsPgRsPgRsPgRsPgRsPgR_TClassManip(TClass* ){ } } // end of namespace ROOT namespace ROOT { // Wrappers around operator new static void *new_vectorlEJTOOLScLcLJResultDerivativelEJTOOLScLcLJResultDerivativelEJTOOLScLcLJResultDerivativelEJTOOLScLcLJResultDerivativelEJTOOLScLcLJResultPDFlEdoublegRsPgRsPgRsPgRsPgRsPgR(void *p) { return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) vector > > > > > : new vector > > > > >; } static void *newArray_vectorlEJTOOLScLcLJResultDerivativelEJTOOLScLcLJResultDerivativelEJTOOLScLcLJResultDerivativelEJTOOLScLcLJResultDerivativelEJTOOLScLcLJResultPDFlEdoublegRsPgRsPgRsPgRsPgRsPgR(Long_t nElements, void *p) { return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) vector > > > > >[nElements] : new vector > > > > >[nElements]; } // Wrapper around operator delete static void delete_vectorlEJTOOLScLcLJResultDerivativelEJTOOLScLcLJResultDerivativelEJTOOLScLcLJResultDerivativelEJTOOLScLcLJResultDerivativelEJTOOLScLcLJResultPDFlEdoublegRsPgRsPgRsPgRsPgRsPgR(void *p) { delete ((vector > > > > >*)p); } static void deleteArray_vectorlEJTOOLScLcLJResultDerivativelEJTOOLScLcLJResultDerivativelEJTOOLScLcLJResultDerivativelEJTOOLScLcLJResultDerivativelEJTOOLScLcLJResultPDFlEdoublegRsPgRsPgRsPgRsPgRsPgR(void *p) { delete [] ((vector > > > > >*)p); } static void destruct_vectorlEJTOOLScLcLJResultDerivativelEJTOOLScLcLJResultDerivativelEJTOOLScLcLJResultDerivativelEJTOOLScLcLJResultDerivativelEJTOOLScLcLJResultPDFlEdoublegRsPgRsPgRsPgRsPgRsPgR(void *p) { typedef vector > > > > > current_t; ((current_t*)p)->~current_t(); } } // end of namespace ROOT for class vector > > > > > namespace ROOT { static TClass *vectorlEJPHYSICScLcLJPDFTablelEJTOOLScLcLJPolintFunction1DlE1cOJTOOLScLcLJPolintElement2SlEdoublecOdoublegRcOJTOOLScLcLJCollectioncOJTOOLScLcLJResultPDFlEdoublegRcOJTOOLScLcLJDistancelEdoublegRsPgRcOJTOOLScLcLJMapListlEJTOOLScLcLJPolint1FunctionalMapHcOJTOOLScLcLJMapListlEJTOOLScLcLJPolint1FunctionalMapHcOJTOOLScLcLJMapListlEJTOOLScLcLJPolint1FunctionalGridMapHcOJTOOLScLcLJMapListlEJTOOLScLcLJPolint1FunctionalGridMapHcOJLANGcLcLJNullTypegRsPgRsPgRsPgRcOJTOOLScLcLJDistancelEdoublegRsPgRsPgR_Dictionary(); static void vectorlEJPHYSICScLcLJPDFTablelEJTOOLScLcLJPolintFunction1DlE1cOJTOOLScLcLJPolintElement2SlEdoublecOdoublegRcOJTOOLScLcLJCollectioncOJTOOLScLcLJResultPDFlEdoublegRcOJTOOLScLcLJDistancelEdoublegRsPgRcOJTOOLScLcLJMapListlEJTOOLScLcLJPolint1FunctionalMapHcOJTOOLScLcLJMapListlEJTOOLScLcLJPolint1FunctionalMapHcOJTOOLScLcLJMapListlEJTOOLScLcLJPolint1FunctionalGridMapHcOJTOOLScLcLJMapListlEJTOOLScLcLJPolint1FunctionalGridMapHcOJLANGcLcLJNullTypegRsPgRsPgRsPgRcOJTOOLScLcLJDistancelEdoublegRsPgRsPgR_TClassManip(TClass*); static void *new_vectorlEJPHYSICScLcLJPDFTablelEJTOOLScLcLJPolintFunction1DlE1cOJTOOLScLcLJPolintElement2SlEdoublecOdoublegRcOJTOOLScLcLJCollectioncOJTOOLScLcLJResultPDFlEdoublegRcOJTOOLScLcLJDistancelEdoublegRsPgRcOJTOOLScLcLJMapListlEJTOOLScLcLJPolint1FunctionalMapHcOJTOOLScLcLJMapListlEJTOOLScLcLJPolint1FunctionalMapHcOJTOOLScLcLJMapListlEJTOOLScLcLJPolint1FunctionalGridMapHcOJTOOLScLcLJMapListlEJTOOLScLcLJPolint1FunctionalGridMapHcOJLANGcLcLJNullTypegRsPgRsPgRsPgRcOJTOOLScLcLJDistancelEdoublegRsPgRsPgR(void *p = 0); static void *newArray_vectorlEJPHYSICScLcLJPDFTablelEJTOOLScLcLJPolintFunction1DlE1cOJTOOLScLcLJPolintElement2SlEdoublecOdoublegRcOJTOOLScLcLJCollectioncOJTOOLScLcLJResultPDFlEdoublegRcOJTOOLScLcLJDistancelEdoublegRsPgRcOJTOOLScLcLJMapListlEJTOOLScLcLJPolint1FunctionalMapHcOJTOOLScLcLJMapListlEJTOOLScLcLJPolint1FunctionalMapHcOJTOOLScLcLJMapListlEJTOOLScLcLJPolint1FunctionalGridMapHcOJTOOLScLcLJMapListlEJTOOLScLcLJPolint1FunctionalGridMapHcOJLANGcLcLJNullTypegRsPgRsPgRsPgRcOJTOOLScLcLJDistancelEdoublegRsPgRsPgR(Long_t size, void *p); static void delete_vectorlEJPHYSICScLcLJPDFTablelEJTOOLScLcLJPolintFunction1DlE1cOJTOOLScLcLJPolintElement2SlEdoublecOdoublegRcOJTOOLScLcLJCollectioncOJTOOLScLcLJResultPDFlEdoublegRcOJTOOLScLcLJDistancelEdoublegRsPgRcOJTOOLScLcLJMapListlEJTOOLScLcLJPolint1FunctionalMapHcOJTOOLScLcLJMapListlEJTOOLScLcLJPolint1FunctionalMapHcOJTOOLScLcLJMapListlEJTOOLScLcLJPolint1FunctionalGridMapHcOJTOOLScLcLJMapListlEJTOOLScLcLJPolint1FunctionalGridMapHcOJLANGcLcLJNullTypegRsPgRsPgRsPgRcOJTOOLScLcLJDistancelEdoublegRsPgRsPgR(void *p); static void deleteArray_vectorlEJPHYSICScLcLJPDFTablelEJTOOLScLcLJPolintFunction1DlE1cOJTOOLScLcLJPolintElement2SlEdoublecOdoublegRcOJTOOLScLcLJCollectioncOJTOOLScLcLJResultPDFlEdoublegRcOJTOOLScLcLJDistancelEdoublegRsPgRcOJTOOLScLcLJMapListlEJTOOLScLcLJPolint1FunctionalMapHcOJTOOLScLcLJMapListlEJTOOLScLcLJPolint1FunctionalMapHcOJTOOLScLcLJMapListlEJTOOLScLcLJPolint1FunctionalGridMapHcOJTOOLScLcLJMapListlEJTOOLScLcLJPolint1FunctionalGridMapHcOJLANGcLcLJNullTypegRsPgRsPgRsPgRcOJTOOLScLcLJDistancelEdoublegRsPgRsPgR(void *p); static void destruct_vectorlEJPHYSICScLcLJPDFTablelEJTOOLScLcLJPolintFunction1DlE1cOJTOOLScLcLJPolintElement2SlEdoublecOdoublegRcOJTOOLScLcLJCollectioncOJTOOLScLcLJResultPDFlEdoublegRcOJTOOLScLcLJDistancelEdoublegRsPgRcOJTOOLScLcLJMapListlEJTOOLScLcLJPolint1FunctionalMapHcOJTOOLScLcLJMapListlEJTOOLScLcLJPolint1FunctionalMapHcOJTOOLScLcLJMapListlEJTOOLScLcLJPolint1FunctionalGridMapHcOJTOOLScLcLJMapListlEJTOOLScLcLJPolint1FunctionalGridMapHcOJLANGcLcLJNullTypegRsPgRsPgRsPgRcOJTOOLScLcLJDistancelEdoublegRsPgRsPgR(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const vector,JTOOLS::JCollection,JTOOLS::JResultPDF,JTOOLS::JDistance >,JTOOLS::JMapList > > >,JTOOLS::JDistance > >*) { vector,JTOOLS::JCollection,JTOOLS::JResultPDF,JTOOLS::JDistance >,JTOOLS::JMapList > > >,JTOOLS::JDistance > > *ptr = 0; static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(vector,JTOOLS::JCollection,JTOOLS::JResultPDF,JTOOLS::JDistance >,JTOOLS::JMapList > > >,JTOOLS::JDistance > >)); static ::ROOT::TGenericClassInfo instance("vector,JTOOLS::JCollection,JTOOLS::JResultPDF,JTOOLS::JDistance >,JTOOLS::JMapList > > >,JTOOLS::JDistance > >", -2, "vector", 210, typeid(vector,JTOOLS::JCollection,JTOOLS::JResultPDF,JTOOLS::JDistance >,JTOOLS::JMapList > > >,JTOOLS::JDistance > >), ::ROOT::Internal::DefineBehavior(ptr, ptr), &vectorlEJPHYSICScLcLJPDFTablelEJTOOLScLcLJPolintFunction1DlE1cOJTOOLScLcLJPolintElement2SlEdoublecOdoublegRcOJTOOLScLcLJCollectioncOJTOOLScLcLJResultPDFlEdoublegRcOJTOOLScLcLJDistancelEdoublegRsPgRcOJTOOLScLcLJMapListlEJTOOLScLcLJPolint1FunctionalMapHcOJTOOLScLcLJMapListlEJTOOLScLcLJPolint1FunctionalMapHcOJTOOLScLcLJMapListlEJTOOLScLcLJPolint1FunctionalGridMapHcOJTOOLScLcLJMapListlEJTOOLScLcLJPolint1FunctionalGridMapHcOJLANGcLcLJNullTypegRsPgRsPgRsPgRcOJTOOLScLcLJDistancelEdoublegRsPgRsPgR_Dictionary, isa_proxy, 0, sizeof(vector,JTOOLS::JCollection,JTOOLS::JResultPDF,JTOOLS::JDistance >,JTOOLS::JMapList > > >,JTOOLS::JDistance > >) ); instance.SetNew(&new_vectorlEJPHYSICScLcLJPDFTablelEJTOOLScLcLJPolintFunction1DlE1cOJTOOLScLcLJPolintElement2SlEdoublecOdoublegRcOJTOOLScLcLJCollectioncOJTOOLScLcLJResultPDFlEdoublegRcOJTOOLScLcLJDistancelEdoublegRsPgRcOJTOOLScLcLJMapListlEJTOOLScLcLJPolint1FunctionalMapHcOJTOOLScLcLJMapListlEJTOOLScLcLJPolint1FunctionalMapHcOJTOOLScLcLJMapListlEJTOOLScLcLJPolint1FunctionalGridMapHcOJTOOLScLcLJMapListlEJTOOLScLcLJPolint1FunctionalGridMapHcOJLANGcLcLJNullTypegRsPgRsPgRsPgRcOJTOOLScLcLJDistancelEdoublegRsPgRsPgR); instance.SetNewArray(&newArray_vectorlEJPHYSICScLcLJPDFTablelEJTOOLScLcLJPolintFunction1DlE1cOJTOOLScLcLJPolintElement2SlEdoublecOdoublegRcOJTOOLScLcLJCollectioncOJTOOLScLcLJResultPDFlEdoublegRcOJTOOLScLcLJDistancelEdoublegRsPgRcOJTOOLScLcLJMapListlEJTOOLScLcLJPolint1FunctionalMapHcOJTOOLScLcLJMapListlEJTOOLScLcLJPolint1FunctionalMapHcOJTOOLScLcLJMapListlEJTOOLScLcLJPolint1FunctionalGridMapHcOJTOOLScLcLJMapListlEJTOOLScLcLJPolint1FunctionalGridMapHcOJLANGcLcLJNullTypegRsPgRsPgRsPgRcOJTOOLScLcLJDistancelEdoublegRsPgRsPgR); instance.SetDelete(&delete_vectorlEJPHYSICScLcLJPDFTablelEJTOOLScLcLJPolintFunction1DlE1cOJTOOLScLcLJPolintElement2SlEdoublecOdoublegRcOJTOOLScLcLJCollectioncOJTOOLScLcLJResultPDFlEdoublegRcOJTOOLScLcLJDistancelEdoublegRsPgRcOJTOOLScLcLJMapListlEJTOOLScLcLJPolint1FunctionalMapHcOJTOOLScLcLJMapListlEJTOOLScLcLJPolint1FunctionalMapHcOJTOOLScLcLJMapListlEJTOOLScLcLJPolint1FunctionalGridMapHcOJTOOLScLcLJMapListlEJTOOLScLcLJPolint1FunctionalGridMapHcOJLANGcLcLJNullTypegRsPgRsPgRsPgRcOJTOOLScLcLJDistancelEdoublegRsPgRsPgR); instance.SetDeleteArray(&deleteArray_vectorlEJPHYSICScLcLJPDFTablelEJTOOLScLcLJPolintFunction1DlE1cOJTOOLScLcLJPolintElement2SlEdoublecOdoublegRcOJTOOLScLcLJCollectioncOJTOOLScLcLJResultPDFlEdoublegRcOJTOOLScLcLJDistancelEdoublegRsPgRcOJTOOLScLcLJMapListlEJTOOLScLcLJPolint1FunctionalMapHcOJTOOLScLcLJMapListlEJTOOLScLcLJPolint1FunctionalMapHcOJTOOLScLcLJMapListlEJTOOLScLcLJPolint1FunctionalGridMapHcOJTOOLScLcLJMapListlEJTOOLScLcLJPolint1FunctionalGridMapHcOJLANGcLcLJNullTypegRsPgRsPgRsPgRcOJTOOLScLcLJDistancelEdoublegRsPgRsPgR); instance.SetDestructor(&destruct_vectorlEJPHYSICScLcLJPDFTablelEJTOOLScLcLJPolintFunction1DlE1cOJTOOLScLcLJPolintElement2SlEdoublecOdoublegRcOJTOOLScLcLJCollectioncOJTOOLScLcLJResultPDFlEdoublegRcOJTOOLScLcLJDistancelEdoublegRsPgRcOJTOOLScLcLJMapListlEJTOOLScLcLJPolint1FunctionalMapHcOJTOOLScLcLJMapListlEJTOOLScLcLJPolint1FunctionalMapHcOJTOOLScLcLJMapListlEJTOOLScLcLJPolint1FunctionalGridMapHcOJTOOLScLcLJMapListlEJTOOLScLcLJPolint1FunctionalGridMapHcOJLANGcLcLJNullTypegRsPgRsPgRsPgRcOJTOOLScLcLJDistancelEdoublegRsPgRsPgR); instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::Pushback< vector,JTOOLS::JCollection,JTOOLS::JResultPDF,JTOOLS::JDistance >,JTOOLS::JMapList > > >,JTOOLS::JDistance > > >())); ::ROOT::AddClassAlternate("vector,JTOOLS::JCollection,JTOOLS::JResultPDF,JTOOLS::JDistance >,JTOOLS::JMapList > > >,JTOOLS::JDistance > >","std::vector, JTOOLS::JCollection, JTOOLS::JResultPDF, JTOOLS::JDistance >, JTOOLS::JMapList > > >, JTOOLS::JDistance >, std::allocator, JTOOLS::JCollection, JTOOLS::JResultPDF, JTOOLS::JDistance >, JTOOLS::JMapList > > >, JTOOLS::JDistance > > >"); return &instance; } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const vector,JTOOLS::JCollection,JTOOLS::JResultPDF,JTOOLS::JDistance >,JTOOLS::JMapList > > >,JTOOLS::JDistance > >*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init)); // Dictionary for non-ClassDef classes static TClass *vectorlEJPHYSICScLcLJPDFTablelEJTOOLScLcLJPolintFunction1DlE1cOJTOOLScLcLJPolintElement2SlEdoublecOdoublegRcOJTOOLScLcLJCollectioncOJTOOLScLcLJResultPDFlEdoublegRcOJTOOLScLcLJDistancelEdoublegRsPgRcOJTOOLScLcLJMapListlEJTOOLScLcLJPolint1FunctionalMapHcOJTOOLScLcLJMapListlEJTOOLScLcLJPolint1FunctionalMapHcOJTOOLScLcLJMapListlEJTOOLScLcLJPolint1FunctionalGridMapHcOJTOOLScLcLJMapListlEJTOOLScLcLJPolint1FunctionalGridMapHcOJLANGcLcLJNullTypegRsPgRsPgRsPgRcOJTOOLScLcLJDistancelEdoublegRsPgRsPgR_Dictionary() { TClass* theClass =::ROOT::GenerateInitInstanceLocal((const vector,JTOOLS::JCollection,JTOOLS::JResultPDF,JTOOLS::JDistance >,JTOOLS::JMapList > > >,JTOOLS::JDistance > >*)0x0)->GetClass(); vectorlEJPHYSICScLcLJPDFTablelEJTOOLScLcLJPolintFunction1DlE1cOJTOOLScLcLJPolintElement2SlEdoublecOdoublegRcOJTOOLScLcLJCollectioncOJTOOLScLcLJResultPDFlEdoublegRcOJTOOLScLcLJDistancelEdoublegRsPgRcOJTOOLScLcLJMapListlEJTOOLScLcLJPolint1FunctionalMapHcOJTOOLScLcLJMapListlEJTOOLScLcLJPolint1FunctionalMapHcOJTOOLScLcLJMapListlEJTOOLScLcLJPolint1FunctionalGridMapHcOJTOOLScLcLJMapListlEJTOOLScLcLJPolint1FunctionalGridMapHcOJLANGcLcLJNullTypegRsPgRsPgRsPgRcOJTOOLScLcLJDistancelEdoublegRsPgRsPgR_TClassManip(theClass); return theClass; } static void vectorlEJPHYSICScLcLJPDFTablelEJTOOLScLcLJPolintFunction1DlE1cOJTOOLScLcLJPolintElement2SlEdoublecOdoublegRcOJTOOLScLcLJCollectioncOJTOOLScLcLJResultPDFlEdoublegRcOJTOOLScLcLJDistancelEdoublegRsPgRcOJTOOLScLcLJMapListlEJTOOLScLcLJPolint1FunctionalMapHcOJTOOLScLcLJMapListlEJTOOLScLcLJPolint1FunctionalMapHcOJTOOLScLcLJMapListlEJTOOLScLcLJPolint1FunctionalGridMapHcOJTOOLScLcLJMapListlEJTOOLScLcLJPolint1FunctionalGridMapHcOJLANGcLcLJNullTypegRsPgRsPgRsPgRcOJTOOLScLcLJDistancelEdoublegRsPgRsPgR_TClassManip(TClass* ){ } } // end of namespace ROOT namespace ROOT { // Wrappers around operator new static void *new_vectorlEJPHYSICScLcLJPDFTablelEJTOOLScLcLJPolintFunction1DlE1cOJTOOLScLcLJPolintElement2SlEdoublecOdoublegRcOJTOOLScLcLJCollectioncOJTOOLScLcLJResultPDFlEdoublegRcOJTOOLScLcLJDistancelEdoublegRsPgRcOJTOOLScLcLJMapListlEJTOOLScLcLJPolint1FunctionalMapHcOJTOOLScLcLJMapListlEJTOOLScLcLJPolint1FunctionalMapHcOJTOOLScLcLJMapListlEJTOOLScLcLJPolint1FunctionalGridMapHcOJTOOLScLcLJMapListlEJTOOLScLcLJPolint1FunctionalGridMapHcOJLANGcLcLJNullTypegRsPgRsPgRsPgRcOJTOOLScLcLJDistancelEdoublegRsPgRsPgR(void *p) { return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) vector,JTOOLS::JCollection,JTOOLS::JResultPDF,JTOOLS::JDistance >,JTOOLS::JMapList > > >,JTOOLS::JDistance > > : new vector,JTOOLS::JCollection,JTOOLS::JResultPDF,JTOOLS::JDistance >,JTOOLS::JMapList > > >,JTOOLS::JDistance > >; } static void *newArray_vectorlEJPHYSICScLcLJPDFTablelEJTOOLScLcLJPolintFunction1DlE1cOJTOOLScLcLJPolintElement2SlEdoublecOdoublegRcOJTOOLScLcLJCollectioncOJTOOLScLcLJResultPDFlEdoublegRcOJTOOLScLcLJDistancelEdoublegRsPgRcOJTOOLScLcLJMapListlEJTOOLScLcLJPolint1FunctionalMapHcOJTOOLScLcLJMapListlEJTOOLScLcLJPolint1FunctionalMapHcOJTOOLScLcLJMapListlEJTOOLScLcLJPolint1FunctionalGridMapHcOJTOOLScLcLJMapListlEJTOOLScLcLJPolint1FunctionalGridMapHcOJLANGcLcLJNullTypegRsPgRsPgRsPgRcOJTOOLScLcLJDistancelEdoublegRsPgRsPgR(Long_t nElements, void *p) { return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) vector,JTOOLS::JCollection,JTOOLS::JResultPDF,JTOOLS::JDistance >,JTOOLS::JMapList > > >,JTOOLS::JDistance > >[nElements] : new vector,JTOOLS::JCollection,JTOOLS::JResultPDF,JTOOLS::JDistance >,JTOOLS::JMapList > > >,JTOOLS::JDistance > >[nElements]; } // Wrapper around operator delete static void delete_vectorlEJPHYSICScLcLJPDFTablelEJTOOLScLcLJPolintFunction1DlE1cOJTOOLScLcLJPolintElement2SlEdoublecOdoublegRcOJTOOLScLcLJCollectioncOJTOOLScLcLJResultPDFlEdoublegRcOJTOOLScLcLJDistancelEdoublegRsPgRcOJTOOLScLcLJMapListlEJTOOLScLcLJPolint1FunctionalMapHcOJTOOLScLcLJMapListlEJTOOLScLcLJPolint1FunctionalMapHcOJTOOLScLcLJMapListlEJTOOLScLcLJPolint1FunctionalGridMapHcOJTOOLScLcLJMapListlEJTOOLScLcLJPolint1FunctionalGridMapHcOJLANGcLcLJNullTypegRsPgRsPgRsPgRcOJTOOLScLcLJDistancelEdoublegRsPgRsPgR(void *p) { delete ((vector,JTOOLS::JCollection,JTOOLS::JResultPDF,JTOOLS::JDistance >,JTOOLS::JMapList > > >,JTOOLS::JDistance > >*)p); } static void deleteArray_vectorlEJPHYSICScLcLJPDFTablelEJTOOLScLcLJPolintFunction1DlE1cOJTOOLScLcLJPolintElement2SlEdoublecOdoublegRcOJTOOLScLcLJCollectioncOJTOOLScLcLJResultPDFlEdoublegRcOJTOOLScLcLJDistancelEdoublegRsPgRcOJTOOLScLcLJMapListlEJTOOLScLcLJPolint1FunctionalMapHcOJTOOLScLcLJMapListlEJTOOLScLcLJPolint1FunctionalMapHcOJTOOLScLcLJMapListlEJTOOLScLcLJPolint1FunctionalGridMapHcOJTOOLScLcLJMapListlEJTOOLScLcLJPolint1FunctionalGridMapHcOJLANGcLcLJNullTypegRsPgRsPgRsPgRcOJTOOLScLcLJDistancelEdoublegRsPgRsPgR(void *p) { delete [] ((vector,JTOOLS::JCollection,JTOOLS::JResultPDF,JTOOLS::JDistance >,JTOOLS::JMapList > > >,JTOOLS::JDistance > >*)p); } static void destruct_vectorlEJPHYSICScLcLJPDFTablelEJTOOLScLcLJPolintFunction1DlE1cOJTOOLScLcLJPolintElement2SlEdoublecOdoublegRcOJTOOLScLcLJCollectioncOJTOOLScLcLJResultPDFlEdoublegRcOJTOOLScLcLJDistancelEdoublegRsPgRcOJTOOLScLcLJMapListlEJTOOLScLcLJPolint1FunctionalMapHcOJTOOLScLcLJMapListlEJTOOLScLcLJPolint1FunctionalMapHcOJTOOLScLcLJMapListlEJTOOLScLcLJPolint1FunctionalGridMapHcOJTOOLScLcLJMapListlEJTOOLScLcLJPolint1FunctionalGridMapHcOJLANGcLcLJNullTypegRsPgRsPgRsPgRcOJTOOLScLcLJDistancelEdoublegRsPgRsPgR(void *p) { typedef vector,JTOOLS::JCollection,JTOOLS::JResultPDF,JTOOLS::JDistance >,JTOOLS::JMapList > > >,JTOOLS::JDistance > > current_t; ((current_t*)p)->~current_t(); } } // end of namespace ROOT for class vector,JTOOLS::JCollection,JTOOLS::JResultPDF,JTOOLS::JDistance >,JTOOLS::JMapList > > >,JTOOLS::JDistance > > namespace ROOT { static TClass *vectorlEJPHYSICScLcLJNPETablelEdoublecOdoublecOJTOOLScLcLJMapListlEJTOOLScLcLJPolint1FunctionalMapHcOJTOOLScLcLJMapListlEJTOOLScLcLJPolint1FunctionalMapHcOJTOOLScLcLJMapListlEJTOOLScLcLJPolint1FunctionalGridMapHcOJTOOLScLcLJMapListlEJTOOLScLcLJPolint1FunctionalGridMapHcOJLANGcLcLJNullTypegRsPgRsPgRsPgRcOJTOOLScLcLJDistancelEdoublegRsPgRsPgR_Dictionary(); static void vectorlEJPHYSICScLcLJNPETablelEdoublecOdoublecOJTOOLScLcLJMapListlEJTOOLScLcLJPolint1FunctionalMapHcOJTOOLScLcLJMapListlEJTOOLScLcLJPolint1FunctionalMapHcOJTOOLScLcLJMapListlEJTOOLScLcLJPolint1FunctionalGridMapHcOJTOOLScLcLJMapListlEJTOOLScLcLJPolint1FunctionalGridMapHcOJLANGcLcLJNullTypegRsPgRsPgRsPgRcOJTOOLScLcLJDistancelEdoublegRsPgRsPgR_TClassManip(TClass*); static void *new_vectorlEJPHYSICScLcLJNPETablelEdoublecOdoublecOJTOOLScLcLJMapListlEJTOOLScLcLJPolint1FunctionalMapHcOJTOOLScLcLJMapListlEJTOOLScLcLJPolint1FunctionalMapHcOJTOOLScLcLJMapListlEJTOOLScLcLJPolint1FunctionalGridMapHcOJTOOLScLcLJMapListlEJTOOLScLcLJPolint1FunctionalGridMapHcOJLANGcLcLJNullTypegRsPgRsPgRsPgRcOJTOOLScLcLJDistancelEdoublegRsPgRsPgR(void *p = 0); static void *newArray_vectorlEJPHYSICScLcLJNPETablelEdoublecOdoublecOJTOOLScLcLJMapListlEJTOOLScLcLJPolint1FunctionalMapHcOJTOOLScLcLJMapListlEJTOOLScLcLJPolint1FunctionalMapHcOJTOOLScLcLJMapListlEJTOOLScLcLJPolint1FunctionalGridMapHcOJTOOLScLcLJMapListlEJTOOLScLcLJPolint1FunctionalGridMapHcOJLANGcLcLJNullTypegRsPgRsPgRsPgRcOJTOOLScLcLJDistancelEdoublegRsPgRsPgR(Long_t size, void *p); static void delete_vectorlEJPHYSICScLcLJNPETablelEdoublecOdoublecOJTOOLScLcLJMapListlEJTOOLScLcLJPolint1FunctionalMapHcOJTOOLScLcLJMapListlEJTOOLScLcLJPolint1FunctionalMapHcOJTOOLScLcLJMapListlEJTOOLScLcLJPolint1FunctionalGridMapHcOJTOOLScLcLJMapListlEJTOOLScLcLJPolint1FunctionalGridMapHcOJLANGcLcLJNullTypegRsPgRsPgRsPgRcOJTOOLScLcLJDistancelEdoublegRsPgRsPgR(void *p); static void deleteArray_vectorlEJPHYSICScLcLJNPETablelEdoublecOdoublecOJTOOLScLcLJMapListlEJTOOLScLcLJPolint1FunctionalMapHcOJTOOLScLcLJMapListlEJTOOLScLcLJPolint1FunctionalMapHcOJTOOLScLcLJMapListlEJTOOLScLcLJPolint1FunctionalGridMapHcOJTOOLScLcLJMapListlEJTOOLScLcLJPolint1FunctionalGridMapHcOJLANGcLcLJNullTypegRsPgRsPgRsPgRcOJTOOLScLcLJDistancelEdoublegRsPgRsPgR(void *p); static void destruct_vectorlEJPHYSICScLcLJNPETablelEdoublecOdoublecOJTOOLScLcLJMapListlEJTOOLScLcLJPolint1FunctionalMapHcOJTOOLScLcLJMapListlEJTOOLScLcLJPolint1FunctionalMapHcOJTOOLScLcLJMapListlEJTOOLScLcLJPolint1FunctionalGridMapHcOJTOOLScLcLJMapListlEJTOOLScLcLJPolint1FunctionalGridMapHcOJLANGcLcLJNullTypegRsPgRsPgRsPgRcOJTOOLScLcLJDistancelEdoublegRsPgRsPgR(void *p); // Function generating the singleton type initializer static TGenericClassInfo *GenerateInitInstanceLocal(const vector > > >,JTOOLS::JDistance > >*) { vector > > >,JTOOLS::JDistance > > *ptr = 0; static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(vector > > >,JTOOLS::JDistance > >)); static ::ROOT::TGenericClassInfo instance("vector > > >,JTOOLS::JDistance > >", -2, "vector", 210, typeid(vector > > >,JTOOLS::JDistance > >), ::ROOT::Internal::DefineBehavior(ptr, ptr), &vectorlEJPHYSICScLcLJNPETablelEdoublecOdoublecOJTOOLScLcLJMapListlEJTOOLScLcLJPolint1FunctionalMapHcOJTOOLScLcLJMapListlEJTOOLScLcLJPolint1FunctionalMapHcOJTOOLScLcLJMapListlEJTOOLScLcLJPolint1FunctionalGridMapHcOJTOOLScLcLJMapListlEJTOOLScLcLJPolint1FunctionalGridMapHcOJLANGcLcLJNullTypegRsPgRsPgRsPgRcOJTOOLScLcLJDistancelEdoublegRsPgRsPgR_Dictionary, isa_proxy, 0, sizeof(vector > > >,JTOOLS::JDistance > >) ); instance.SetNew(&new_vectorlEJPHYSICScLcLJNPETablelEdoublecOdoublecOJTOOLScLcLJMapListlEJTOOLScLcLJPolint1FunctionalMapHcOJTOOLScLcLJMapListlEJTOOLScLcLJPolint1FunctionalMapHcOJTOOLScLcLJMapListlEJTOOLScLcLJPolint1FunctionalGridMapHcOJTOOLScLcLJMapListlEJTOOLScLcLJPolint1FunctionalGridMapHcOJLANGcLcLJNullTypegRsPgRsPgRsPgRcOJTOOLScLcLJDistancelEdoublegRsPgRsPgR); instance.SetNewArray(&newArray_vectorlEJPHYSICScLcLJNPETablelEdoublecOdoublecOJTOOLScLcLJMapListlEJTOOLScLcLJPolint1FunctionalMapHcOJTOOLScLcLJMapListlEJTOOLScLcLJPolint1FunctionalMapHcOJTOOLScLcLJMapListlEJTOOLScLcLJPolint1FunctionalGridMapHcOJTOOLScLcLJMapListlEJTOOLScLcLJPolint1FunctionalGridMapHcOJLANGcLcLJNullTypegRsPgRsPgRsPgRcOJTOOLScLcLJDistancelEdoublegRsPgRsPgR); instance.SetDelete(&delete_vectorlEJPHYSICScLcLJNPETablelEdoublecOdoublecOJTOOLScLcLJMapListlEJTOOLScLcLJPolint1FunctionalMapHcOJTOOLScLcLJMapListlEJTOOLScLcLJPolint1FunctionalMapHcOJTOOLScLcLJMapListlEJTOOLScLcLJPolint1FunctionalGridMapHcOJTOOLScLcLJMapListlEJTOOLScLcLJPolint1FunctionalGridMapHcOJLANGcLcLJNullTypegRsPgRsPgRsPgRcOJTOOLScLcLJDistancelEdoublegRsPgRsPgR); instance.SetDeleteArray(&deleteArray_vectorlEJPHYSICScLcLJNPETablelEdoublecOdoublecOJTOOLScLcLJMapListlEJTOOLScLcLJPolint1FunctionalMapHcOJTOOLScLcLJMapListlEJTOOLScLcLJPolint1FunctionalMapHcOJTOOLScLcLJMapListlEJTOOLScLcLJPolint1FunctionalGridMapHcOJTOOLScLcLJMapListlEJTOOLScLcLJPolint1FunctionalGridMapHcOJLANGcLcLJNullTypegRsPgRsPgRsPgRcOJTOOLScLcLJDistancelEdoublegRsPgRsPgR); instance.SetDestructor(&destruct_vectorlEJPHYSICScLcLJNPETablelEdoublecOdoublecOJTOOLScLcLJMapListlEJTOOLScLcLJPolint1FunctionalMapHcOJTOOLScLcLJMapListlEJTOOLScLcLJPolint1FunctionalMapHcOJTOOLScLcLJMapListlEJTOOLScLcLJPolint1FunctionalGridMapHcOJTOOLScLcLJMapListlEJTOOLScLcLJPolint1FunctionalGridMapHcOJLANGcLcLJNullTypegRsPgRsPgRsPgRcOJTOOLScLcLJDistancelEdoublegRsPgRsPgR); instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::Pushback< vector > > >,JTOOLS::JDistance > > >())); ::ROOT::AddClassAlternate("vector > > >,JTOOLS::JDistance > >","std::vector > > >, JTOOLS::JDistance >, std::allocator > > >, JTOOLS::JDistance > > >"); return &instance; } // Static variable to force the class initialization static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const vector > > >,JTOOLS::JDistance > >*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init)); // Dictionary for non-ClassDef classes static TClass *vectorlEJPHYSICScLcLJNPETablelEdoublecOdoublecOJTOOLScLcLJMapListlEJTOOLScLcLJPolint1FunctionalMapHcOJTOOLScLcLJMapListlEJTOOLScLcLJPolint1FunctionalMapHcOJTOOLScLcLJMapListlEJTOOLScLcLJPolint1FunctionalGridMapHcOJTOOLScLcLJMapListlEJTOOLScLcLJPolint1FunctionalGridMapHcOJLANGcLcLJNullTypegRsPgRsPgRsPgRcOJTOOLScLcLJDistancelEdoublegRsPgRsPgR_Dictionary() { TClass* theClass =::ROOT::GenerateInitInstanceLocal((const vector > > >,JTOOLS::JDistance > >*)0x0)->GetClass(); vectorlEJPHYSICScLcLJNPETablelEdoublecOdoublecOJTOOLScLcLJMapListlEJTOOLScLcLJPolint1FunctionalMapHcOJTOOLScLcLJMapListlEJTOOLScLcLJPolint1FunctionalMapHcOJTOOLScLcLJMapListlEJTOOLScLcLJPolint1FunctionalGridMapHcOJTOOLScLcLJMapListlEJTOOLScLcLJPolint1FunctionalGridMapHcOJLANGcLcLJNullTypegRsPgRsPgRsPgRcOJTOOLScLcLJDistancelEdoublegRsPgRsPgR_TClassManip(theClass); return theClass; } static void vectorlEJPHYSICScLcLJNPETablelEdoublecOdoublecOJTOOLScLcLJMapListlEJTOOLScLcLJPolint1FunctionalMapHcOJTOOLScLcLJMapListlEJTOOLScLcLJPolint1FunctionalMapHcOJTOOLScLcLJMapListlEJTOOLScLcLJPolint1FunctionalGridMapHcOJTOOLScLcLJMapListlEJTOOLScLcLJPolint1FunctionalGridMapHcOJLANGcLcLJNullTypegRsPgRsPgRsPgRcOJTOOLScLcLJDistancelEdoublegRsPgRsPgR_TClassManip(TClass* ){ } } // end of namespace ROOT namespace ROOT { // Wrappers around operator new static void *new_vectorlEJPHYSICScLcLJNPETablelEdoublecOdoublecOJTOOLScLcLJMapListlEJTOOLScLcLJPolint1FunctionalMapHcOJTOOLScLcLJMapListlEJTOOLScLcLJPolint1FunctionalMapHcOJTOOLScLcLJMapListlEJTOOLScLcLJPolint1FunctionalGridMapHcOJTOOLScLcLJMapListlEJTOOLScLcLJPolint1FunctionalGridMapHcOJLANGcLcLJNullTypegRsPgRsPgRsPgRcOJTOOLScLcLJDistancelEdoublegRsPgRsPgR(void *p) { return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) vector > > >,JTOOLS::JDistance > > : new vector > > >,JTOOLS::JDistance > >; } static void *newArray_vectorlEJPHYSICScLcLJNPETablelEdoublecOdoublecOJTOOLScLcLJMapListlEJTOOLScLcLJPolint1FunctionalMapHcOJTOOLScLcLJMapListlEJTOOLScLcLJPolint1FunctionalMapHcOJTOOLScLcLJMapListlEJTOOLScLcLJPolint1FunctionalGridMapHcOJTOOLScLcLJMapListlEJTOOLScLcLJPolint1FunctionalGridMapHcOJLANGcLcLJNullTypegRsPgRsPgRsPgRcOJTOOLScLcLJDistancelEdoublegRsPgRsPgR(Long_t nElements, void *p) { return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) vector > > >,JTOOLS::JDistance > >[nElements] : new vector > > >,JTOOLS::JDistance > >[nElements]; } // Wrapper around operator delete static void delete_vectorlEJPHYSICScLcLJNPETablelEdoublecOdoublecOJTOOLScLcLJMapListlEJTOOLScLcLJPolint1FunctionalMapHcOJTOOLScLcLJMapListlEJTOOLScLcLJPolint1FunctionalMapHcOJTOOLScLcLJMapListlEJTOOLScLcLJPolint1FunctionalGridMapHcOJTOOLScLcLJMapListlEJTOOLScLcLJPolint1FunctionalGridMapHcOJLANGcLcLJNullTypegRsPgRsPgRsPgRcOJTOOLScLcLJDistancelEdoublegRsPgRsPgR(void *p) { delete ((vector > > >,JTOOLS::JDistance > >*)p); } static void deleteArray_vectorlEJPHYSICScLcLJNPETablelEdoublecOdoublecOJTOOLScLcLJMapListlEJTOOLScLcLJPolint1FunctionalMapHcOJTOOLScLcLJMapListlEJTOOLScLcLJPolint1FunctionalMapHcOJTOOLScLcLJMapListlEJTOOLScLcLJPolint1FunctionalGridMapHcOJTOOLScLcLJMapListlEJTOOLScLcLJPolint1FunctionalGridMapHcOJLANGcLcLJNullTypegRsPgRsPgRsPgRcOJTOOLScLcLJDistancelEdoublegRsPgRsPgR(void *p) { delete [] ((vector > > >,JTOOLS::JDistance > >*)p); } static void destruct_vectorlEJPHYSICScLcLJNPETablelEdoublecOdoublecOJTOOLScLcLJMapListlEJTOOLScLcLJPolint1FunctionalMapHcOJTOOLScLcLJMapListlEJTOOLScLcLJPolint1FunctionalMapHcOJTOOLScLcLJMapListlEJTOOLScLcLJPolint1FunctionalGridMapHcOJTOOLScLcLJMapListlEJTOOLScLcLJPolint1FunctionalGridMapHcOJLANGcLcLJNullTypegRsPgRsPgRsPgRcOJTOOLScLcLJDistancelEdoublegRsPgRsPgR(void *p) { typedef vector > > >,JTOOLS::JDistance > > current_t; ((current_t*)p)->~current_t(); } } // end of namespace ROOT for class vector > > >,JTOOLS::JDistance > > namespace { void TriggerDictionaryInitialization_JppGraddOdict_Impl() { static const char* headers[] = { "JppGrad.hh", 0 }; static const char* includePaths[] = { "/usr/local/include", "/km3net/aanet/evt", "/km3net/aanet/astro", "/km3net/aanet", "/km3net/aanet/externals", "/km3net/aanet/externals/km3net-dataformat/offline", "/km3net/aanet/externals/km3net-dataformat/online", "/km3net/aanet/externals/flux", "/Jpp/software/", "/Jpp/externals/antares-daq/include/", "/usr/local/include/", "/km3net/aanet/rec/rec2/", 0 }; static const char* fwdDeclCode = R"DICTFWDDCLS( #line 1 "JppGraddOdict 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(R"ATTRDUMP(file_name@@@JppGrad.hh)ATTRDUMP"))) __attribute__((annotate(R"ATTRDUMP(pattern@@@*)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$JppGrad.hh"))) JppGrad; )DICTFWDDCLS"; static const char* payloadCode = R"DICTPAYLOAD( #line 1 "JppGraddOdict dictionary payload" #ifndef HAVEJPP #define HAVEJPP 1 #endif #define _BACKWARD_BACKWARD_WARNING_H // Inline headers #include "JppGrad.hh" #undef _BACKWARD_BACKWARD_WARNING_H )DICTPAYLOAD"; static const char* classesHeaders[] = { "", payloadCode, "@", "JppGrad", payloadCode, "@", "getAbsorptionLength", payloadCode, "@", "getScatteringLength", payloadCode, "@", nullptr }; static bool isInitialized = false; if (!isInitialized) { TROOT::RegisterModule("JppGrad.dict", headers, includePaths, payloadCode, fwdDeclCode, TriggerDictionaryInitialization_JppGraddOdict_Impl, {}, classesHeaders, /*hasCxxModule*/false); isInitialized = true; } } static struct DictInit { DictInit() { TriggerDictionaryInitialization_JppGraddOdict_Impl(); } } __TheDictionaryInitializer; } void TriggerDictionaryInitialization_JppGraddOdict() { TriggerDictionaryInitialization_JppGraddOdict_Impl(); }