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

#define R__DICTIONARY_FILENAME dIkm3netdIaanetdIbuilddIdIsladOdict
#define R__NO_DEPRECATION

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

// The generated code does not explicitly qualifies STL entities
namespace std {} using namespace std;

// Header files passed as explicit arguments
#include "sla.hh"

// Header files passed via #pragma extra_include

namespace sla {
   namespace ROOT {
      inline ::ROOT::TGenericClassInfo *GenerateInitInstance();
      static TClass *sla_Dictionary();

      // Function generating the singleton type initializer
      inline ::ROOT::TGenericClassInfo *GenerateInitInstance()
      {
         static ::ROOT::TGenericClassInfo 
            instance("sla", 0 /*version*/, "sla.hh", 191,
                     ::ROOT::Internal::DefineBehavior((void*)0,(void*)0),
                     &sla_Dictionary, 0);
         return &instance;
      }
      // Insure that the inline function is _not_ optimized away by the compiler
      ::ROOT::TGenericClassInfo *(*_R__UNIQUE_DICT_(InitFunctionKeeper))() = &GenerateInitInstance;  
      // Static variable to force the class initialization
      static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstance(); R__UseDummy(_R__UNIQUE_DICT_(Init));

      // Dictionary for non-ClassDef classes
      static TClass *sla_Dictionary() {
         return GenerateInitInstance()->GetClass();
      }

   }
}

namespace ROOT {
   static TClass *slacLcL_pointablelEintgR_Dictionary();
   static void slacLcL_pointablelEintgR_TClassManip(TClass*);
   static void delete_slacLcL_pointablelEintgR(void *p);
   static void deleteArray_slacLcL_pointablelEintgR(void *p);
   static void destruct_slacLcL_pointablelEintgR(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::sla::_pointable<int>*)
   {
      ::sla::_pointable<int> *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::sla::_pointable<int>));
      static ::ROOT::TGenericClassInfo 
         instance("sla::_pointable<int>", "sla.hh", 196,
                  typeid(::sla::_pointable<int>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &slacLcL_pointablelEintgR_Dictionary, isa_proxy, 4,
                  sizeof(::sla::_pointable<int>) );
      instance.SetDelete(&delete_slacLcL_pointablelEintgR);
      instance.SetDeleteArray(&deleteArray_slacLcL_pointablelEintgR);
      instance.SetDestructor(&destruct_slacLcL_pointablelEintgR);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::sla::_pointable<int>*)
   {
      return GenerateInitInstanceLocal((::sla::_pointable<int>*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::sla::_pointable<int>*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *slacLcL_pointablelEintgR_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::sla::_pointable<int>*)0x0)->GetClass();
      slacLcL_pointablelEintgR_TClassManip(theClass);
   return theClass;
   }

   static void slacLcL_pointablelEintgR_TClassManip(TClass* theClass){
      theClass->CreateAttributeMap();
      TDictAttributeMap* attrMap( theClass->GetAttributeMap() );
      attrMap->AddProperty("file_name","sla.hh");
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *slacLcLpv2el_Dictionary();
   static void slacLcLpv2el_TClassManip(TClass*);
   static void delete_slacLcLpv2el(void *p);
   static void deleteArray_slacLcLpv2el(void *p);
   static void destruct_slacLcLpv2el(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::sla::pv2el*)
   {
      ::sla::pv2el *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::sla::pv2el));
      static ::ROOT::TGenericClassInfo 
         instance("sla::pv2el", "sla.hh", 345,
                  typeid(::sla::pv2el), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &slacLcLpv2el_Dictionary, isa_proxy, 4,
                  sizeof(::sla::pv2el) );
      instance.SetDelete(&delete_slacLcLpv2el);
      instance.SetDeleteArray(&deleteArray_slacLcLpv2el);
      instance.SetDestructor(&destruct_slacLcLpv2el);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::sla::pv2el*)
   {
      return GenerateInitInstanceLocal((::sla::pv2el*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::sla::pv2el*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *slacLcLpv2el_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::sla::pv2el*)0x0)->GetClass();
      slacLcLpv2el_TClassManip(theClass);
   return theClass;
   }

   static void slacLcLpv2el_TClassManip(TClass* theClass){
      theClass->CreateAttributeMap();
      TDictAttributeMap* attrMap( theClass->GetAttributeMap() );
      attrMap->AddProperty("file_name","sla.hh");
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *slacLcLgeoc_Dictionary();
   static void slacLcLgeoc_TClassManip(TClass*);
   static void delete_slacLcLgeoc(void *p);
   static void deleteArray_slacLcLgeoc(void *p);
   static void destruct_slacLcLgeoc(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::sla::geoc*)
   {
      ::sla::geoc *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::sla::geoc));
      static ::ROOT::TGenericClassInfo 
         instance("sla::geoc", "sla.hh", 395,
                  typeid(::sla::geoc), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &slacLcLgeoc_Dictionary, isa_proxy, 4,
                  sizeof(::sla::geoc) );
      instance.SetDelete(&delete_slacLcLgeoc);
      instance.SetDeleteArray(&deleteArray_slacLcLgeoc);
      instance.SetDestructor(&destruct_slacLcLgeoc);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::sla::geoc*)
   {
      return GenerateInitInstanceLocal((::sla::geoc*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::sla::geoc*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *slacLcLgeoc_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::sla::geoc*)0x0)->GetClass();
      slacLcLgeoc_TClassManip(theClass);
   return theClass;
   }

   static void slacLcLgeoc_TClassManip(TClass* theClass){
      theClass->CreateAttributeMap();
      TDictAttributeMap* attrMap( theClass->GetAttributeMap() );
      attrMap->AddProperty("file_name","sla.hh");
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *slacLcLampqk_Dictionary();
   static void slacLcLampqk_TClassManip(TClass*);
   static void delete_slacLcLampqk(void *p);
   static void deleteArray_slacLcLampqk(void *p);
   static void destruct_slacLcLampqk(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::sla::ampqk*)
   {
      ::sla::ampqk *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::sla::ampqk));
      static ::ROOT::TGenericClassInfo 
         instance("sla::ampqk", "sla.hh", 498,
                  typeid(::sla::ampqk), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &slacLcLampqk_Dictionary, isa_proxy, 4,
                  sizeof(::sla::ampqk) );
      instance.SetDelete(&delete_slacLcLampqk);
      instance.SetDeleteArray(&deleteArray_slacLcLampqk);
      instance.SetDestructor(&destruct_slacLcLampqk);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::sla::ampqk*)
   {
      return GenerateInitInstanceLocal((::sla::ampqk*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::sla::ampqk*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *slacLcLampqk_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::sla::ampqk*)0x0)->GetClass();
      slacLcLampqk_TClassManip(theClass);
   return theClass;
   }

   static void slacLcLampqk_TClassManip(TClass* theClass){
      theClass->CreateAttributeMap();
      TDictAttributeMap* attrMap( theClass->GetAttributeMap() );
      attrMap->AddProperty("file_name","sla.hh");
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *slacLcLaoppat_Dictionary();
   static void slacLcLaoppat_TClassManip(TClass*);
   static void delete_slacLcLaoppat(void *p);
   static void deleteArray_slacLcLaoppat(void *p);
   static void destruct_slacLcLaoppat(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::sla::aoppat*)
   {
      ::sla::aoppat *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::sla::aoppat));
      static ::ROOT::TGenericClassInfo 
         instance("sla::aoppat", "sla.hh", 551,
                  typeid(::sla::aoppat), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &slacLcLaoppat_Dictionary, isa_proxy, 4,
                  sizeof(::sla::aoppat) );
      instance.SetDelete(&delete_slacLcLaoppat);
      instance.SetDeleteArray(&deleteArray_slacLcLaoppat);
      instance.SetDestructor(&destruct_slacLcLaoppat);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::sla::aoppat*)
   {
      return GenerateInitInstanceLocal((::sla::aoppat*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::sla::aoppat*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *slacLcLaoppat_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::sla::aoppat*)0x0)->GetClass();
      slacLcLaoppat_TClassManip(theClass);
   return theClass;
   }

   static void slacLcLaoppat_TClassManip(TClass* theClass){
      theClass->CreateAttributeMap();
      TDictAttributeMap* attrMap( theClass->GetAttributeMap() );
      attrMap->AddProperty("file_name","sla.hh");
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *slacLcLdafin_Dictionary();
   static void slacLcLdafin_TClassManip(TClass*);
   static void delete_slacLcLdafin(void *p);
   static void deleteArray_slacLcLdafin(void *p);
   static void destruct_slacLcLdafin(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::sla::dafin*)
   {
      ::sla::dafin *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::sla::dafin));
      static ::ROOT::TGenericClassInfo 
         instance("sla::dafin", "sla.hh", 680,
                  typeid(::sla::dafin), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &slacLcLdafin_Dictionary, isa_proxy, 4,
                  sizeof(::sla::dafin) );
      instance.SetDelete(&delete_slacLcLdafin);
      instance.SetDeleteArray(&deleteArray_slacLcLdafin);
      instance.SetDestructor(&destruct_slacLcLdafin);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::sla::dafin*)
   {
      return GenerateInitInstanceLocal((::sla::dafin*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::sla::dafin*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *slacLcLdafin_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::sla::dafin*)0x0)->GetClass();
      slacLcLdafin_TClassManip(theClass);
   return theClass;
   }

   static void slacLcLdafin_TClassManip(TClass* theClass){
      theClass->CreateAttributeMap();
      TDictAttributeMap* attrMap( theClass->GetAttributeMap() );
      attrMap->AddProperty("file_name","sla.hh");
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *slacLcLecmat_Dictionary();
   static void slacLcLecmat_TClassManip(TClass*);
   static void delete_slacLcLecmat(void *p);
   static void deleteArray_slacLcLecmat(void *p);
   static void destruct_slacLcLecmat(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::sla::ecmat*)
   {
      ::sla::ecmat *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::sla::ecmat));
      static ::ROOT::TGenericClassInfo 
         instance("sla::ecmat", "sla.hh", 728,
                  typeid(::sla::ecmat), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &slacLcLecmat_Dictionary, isa_proxy, 4,
                  sizeof(::sla::ecmat) );
      instance.SetDelete(&delete_slacLcLecmat);
      instance.SetDeleteArray(&deleteArray_slacLcLecmat);
      instance.SetDestructor(&destruct_slacLcLecmat);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::sla::ecmat*)
   {
      return GenerateInitInstanceLocal((::sla::ecmat*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::sla::ecmat*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *slacLcLecmat_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::sla::ecmat*)0x0)->GetClass();
      slacLcLecmat_TClassManip(theClass);
   return theClass;
   }

   static void slacLcLecmat_TClassManip(TClass* theClass){
      theClass->CreateAttributeMap();
      TDictAttributeMap* attrMap( theClass->GetAttributeMap() );
      attrMap->AddProperty("file_name","sla.hh");
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *slacLcLamp_Dictionary();
   static void slacLcLamp_TClassManip(TClass*);
   static void delete_slacLcLamp(void *p);
   static void deleteArray_slacLcLamp(void *p);
   static void destruct_slacLcLamp(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::sla::amp*)
   {
      ::sla::amp *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::sla::amp));
      static ::ROOT::TGenericClassInfo 
         instance("sla::amp", "sla.hh", 806,
                  typeid(::sla::amp), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &slacLcLamp_Dictionary, isa_proxy, 4,
                  sizeof(::sla::amp) );
      instance.SetDelete(&delete_slacLcLamp);
      instance.SetDeleteArray(&deleteArray_slacLcLamp);
      instance.SetDestructor(&destruct_slacLcLamp);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::sla::amp*)
   {
      return GenerateInitInstanceLocal((::sla::amp*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::sla::amp*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *slacLcLamp_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::sla::amp*)0x0)->GetClass();
      slacLcLamp_TClassManip(theClass);
   return theClass;
   }

   static void slacLcLamp_TClassManip(TClass* theClass){
      theClass->CreateAttributeMap();
      TDictAttributeMap* attrMap( theClass->GetAttributeMap() );
      attrMap->AddProperty("file_name","sla.hh");
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *slacLcLtp2v_Dictionary();
   static void slacLcLtp2v_TClassManip(TClass*);
   static void delete_slacLcLtp2v(void *p);
   static void deleteArray_slacLcLtp2v(void *p);
   static void destruct_slacLcLtp2v(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::sla::tp2v*)
   {
      ::sla::tp2v *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::sla::tp2v));
      static ::ROOT::TGenericClassInfo 
         instance("sla::tp2v", "sla.hh", 860,
                  typeid(::sla::tp2v), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &slacLcLtp2v_Dictionary, isa_proxy, 4,
                  sizeof(::sla::tp2v) );
      instance.SetDelete(&delete_slacLcLtp2v);
      instance.SetDeleteArray(&deleteArray_slacLcLtp2v);
      instance.SetDestructor(&destruct_slacLcLtp2v);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::sla::tp2v*)
   {
      return GenerateInitInstanceLocal((::sla::tp2v*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::sla::tp2v*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *slacLcLtp2v_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::sla::tp2v*)0x0)->GetClass();
      slacLcLtp2v_TClassManip(theClass);
   return theClass;
   }

   static void slacLcLtp2v_TClassManip(TClass* theClass){
      theClass->CreateAttributeMap();
      TDictAttributeMap* attrMap( theClass->GetAttributeMap() );
      attrMap->AddProperty("file_name","sla.hh");
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *slacLcLrefz_Dictionary();
   static void slacLcLrefz_TClassManip(TClass*);
   static void delete_slacLcLrefz(void *p);
   static void deleteArray_slacLcLrefz(void *p);
   static void destruct_slacLcLrefz(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::sla::refz*)
   {
      ::sla::refz *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::sla::refz));
      static ::ROOT::TGenericClassInfo 
         instance("sla::refz", "sla.hh", 965,
                  typeid(::sla::refz), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &slacLcLrefz_Dictionary, isa_proxy, 4,
                  sizeof(::sla::refz) );
      instance.SetDelete(&delete_slacLcLrefz);
      instance.SetDeleteArray(&deleteArray_slacLcLrefz);
      instance.SetDestructor(&destruct_slacLcLrefz);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::sla::refz*)
   {
      return GenerateInitInstanceLocal((::sla::refz*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::sla::refz*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *slacLcLrefz_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::sla::refz*)0x0)->GetClass();
      slacLcLrefz_TClassManip(theClass);
   return theClass;
   }

   static void slacLcLrefz_TClassManip(TClass* theClass){
      theClass->CreateAttributeMap();
      TDictAttributeMap* attrMap( theClass->GetAttributeMap() );
      attrMap->AddProperty("file_name","sla.hh");
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *slacLcLcaldj_Dictionary();
   static void slacLcLcaldj_TClassManip(TClass*);
   static void delete_slacLcLcaldj(void *p);
   static void deleteArray_slacLcLcaldj(void *p);
   static void destruct_slacLcLcaldj(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::sla::caldj*)
   {
      ::sla::caldj *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::sla::caldj));
      static ::ROOT::TGenericClassInfo 
         instance("sla::caldj", "sla.hh", 1017,
                  typeid(::sla::caldj), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &slacLcLcaldj_Dictionary, isa_proxy, 4,
                  sizeof(::sla::caldj) );
      instance.SetDelete(&delete_slacLcLcaldj);
      instance.SetDeleteArray(&deleteArray_slacLcLcaldj);
      instance.SetDestructor(&destruct_slacLcLcaldj);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::sla::caldj*)
   {
      return GenerateInitInstanceLocal((::sla::caldj*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::sla::caldj*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *slacLcLcaldj_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::sla::caldj*)0x0)->GetClass();
      slacLcLcaldj_TClassManip(theClass);
   return theClass;
   }

   static void slacLcLcaldj_TClassManip(TClass* theClass){
      theClass->CreateAttributeMap();
      TDictAttributeMap* attrMap( theClass->GetAttributeMap() );
      attrMap->AddProperty("file_name","sla.hh");
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *slacLcLcalyd_Dictionary();
   static void slacLcLcalyd_TClassManip(TClass*);
   static void delete_slacLcLcalyd(void *p);
   static void deleteArray_slacLcLcalyd(void *p);
   static void destruct_slacLcLcalyd(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::sla::calyd*)
   {
      ::sla::calyd *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::sla::calyd));
      static ::ROOT::TGenericClassInfo 
         instance("sla::calyd", "sla.hh", 1119,
                  typeid(::sla::calyd), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &slacLcLcalyd_Dictionary, isa_proxy, 4,
                  sizeof(::sla::calyd) );
      instance.SetDelete(&delete_slacLcLcalyd);
      instance.SetDeleteArray(&deleteArray_slacLcLcalyd);
      instance.SetDestructor(&destruct_slacLcLcalyd);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::sla::calyd*)
   {
      return GenerateInitInstanceLocal((::sla::calyd*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::sla::calyd*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *slacLcLcalyd_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::sla::calyd*)0x0)->GetClass();
      slacLcLcalyd_TClassManip(theClass);
   return theClass;
   }

   static void slacLcLcalyd_TClassManip(TClass* theClass){
      theClass->CreateAttributeMap();
      TDictAttributeMap* attrMap( theClass->GetAttributeMap() );
      attrMap->AddProperty("file_name","sla.hh");
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *slacLcLmxv_Dictionary();
   static void slacLcLmxv_TClassManip(TClass*);
   static void delete_slacLcLmxv(void *p);
   static void deleteArray_slacLcLmxv(void *p);
   static void destruct_slacLcLmxv(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::sla::mxv*)
   {
      ::sla::mxv *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::sla::mxv));
      static ::ROOT::TGenericClassInfo 
         instance("sla::mxv", "sla.hh", 1206,
                  typeid(::sla::mxv), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &slacLcLmxv_Dictionary, isa_proxy, 4,
                  sizeof(::sla::mxv) );
      instance.SetDelete(&delete_slacLcLmxv);
      instance.SetDeleteArray(&deleteArray_slacLcLmxv);
      instance.SetDestructor(&destruct_slacLcLmxv);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::sla::mxv*)
   {
      return GenerateInitInstanceLocal((::sla::mxv*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::sla::mxv*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *slacLcLmxv_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::sla::mxv*)0x0)->GetClass();
      slacLcLmxv_TClassManip(theClass);
   return theClass;
   }

   static void slacLcLmxv_TClassManip(TClass* theClass){
      theClass->CreateAttributeMap();
      TDictAttributeMap* attrMap( theClass->GetAttributeMap() );
      attrMap->AddProperty("file_name","sla.hh");
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *slacLcLepv_Dictionary();
   static void slacLcLepv_TClassManip(TClass*);
   static void delete_slacLcLepv(void *p);
   static void deleteArray_slacLcLepv(void *p);
   static void destruct_slacLcLepv(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::sla::epv*)
   {
      ::sla::epv *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::sla::epv));
      static ::ROOT::TGenericClassInfo 
         instance("sla::epv", "sla.hh", 1299,
                  typeid(::sla::epv), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &slacLcLepv_Dictionary, isa_proxy, 4,
                  sizeof(::sla::epv) );
      instance.SetDelete(&delete_slacLcLepv);
      instance.SetDeleteArray(&deleteArray_slacLcLepv);
      instance.SetDestructor(&destruct_slacLcLepv);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::sla::epv*)
   {
      return GenerateInitInstanceLocal((::sla::epv*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::sla::epv*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *slacLcLepv_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::sla::epv*)0x0)->GetClass();
      slacLcLepv_TClassManip(theClass);
   return theClass;
   }

   static void slacLcLepv_TClassManip(TClass* theClass){
      theClass->CreateAttributeMap();
      TDictAttributeMap* attrMap( theClass->GetAttributeMap() );
      attrMap->AddProperty("file_name","sla.hh");
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *slacLcLdtf2d_Dictionary();
   static void slacLcLdtf2d_TClassManip(TClass*);
   static void delete_slacLcLdtf2d(void *p);
   static void deleteArray_slacLcLdtf2d(void *p);
   static void destruct_slacLcLdtf2d(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::sla::dtf2d*)
   {
      ::sla::dtf2d *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::sla::dtf2d));
      static ::ROOT::TGenericClassInfo 
         instance("sla::dtf2d", "sla.hh", 1370,
                  typeid(::sla::dtf2d), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &slacLcLdtf2d_Dictionary, isa_proxy, 4,
                  sizeof(::sla::dtf2d) );
      instance.SetDelete(&delete_slacLcLdtf2d);
      instance.SetDeleteArray(&deleteArray_slacLcLdtf2d);
      instance.SetDestructor(&destruct_slacLcLdtf2d);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::sla::dtf2d*)
   {
      return GenerateInitInstanceLocal((::sla::dtf2d*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::sla::dtf2d*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *slacLcLdtf2d_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::sla::dtf2d*)0x0)->GetClass();
      slacLcLdtf2d_TClassManip(theClass);
   return theClass;
   }

   static void slacLcLdtf2d_TClassManip(TClass* theClass){
      theClass->CreateAttributeMap();
      TDictAttributeMap* attrMap( theClass->GetAttributeMap() );
      attrMap->AddProperty("file_name","sla.hh");
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *slacLcLgalsup_Dictionary();
   static void slacLcLgalsup_TClassManip(TClass*);
   static void delete_slacLcLgalsup(void *p);
   static void deleteArray_slacLcLgalsup(void *p);
   static void destruct_slacLcLgalsup(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::sla::galsup*)
   {
      ::sla::galsup *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::sla::galsup));
      static ::ROOT::TGenericClassInfo 
         instance("sla::galsup", "sla.hh", 1427,
                  typeid(::sla::galsup), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &slacLcLgalsup_Dictionary, isa_proxy, 4,
                  sizeof(::sla::galsup) );
      instance.SetDelete(&delete_slacLcLgalsup);
      instance.SetDeleteArray(&deleteArray_slacLcLgalsup);
      instance.SetDestructor(&destruct_slacLcLgalsup);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::sla::galsup*)
   {
      return GenerateInitInstanceLocal((::sla::galsup*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::sla::galsup*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *slacLcLgalsup_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::sla::galsup*)0x0)->GetClass();
      slacLcLgalsup_TClassManip(theClass);
   return theClass;
   }

   static void slacLcLgalsup_TClassManip(TClass* theClass){
      theClass->CreateAttributeMap();
      TDictAttributeMap* attrMap( theClass->GetAttributeMap() );
      attrMap->AddProperty("file_name","sla.hh");
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *slacLcLpreces_Dictionary();
   static void slacLcLpreces_TClassManip(TClass*);
   static void delete_slacLcLpreces(void *p);
   static void deleteArray_slacLcLpreces(void *p);
   static void destruct_slacLcLpreces(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::sla::preces*)
   {
      ::sla::preces *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::sla::preces));
      static ::ROOT::TGenericClassInfo 
         instance("sla::preces", "sla.hh", 1488,
                  typeid(::sla::preces), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &slacLcLpreces_Dictionary, isa_proxy, 4,
                  sizeof(::sla::preces) );
      instance.SetDelete(&delete_slacLcLpreces);
      instance.SetDeleteArray(&deleteArray_slacLcLpreces);
      instance.SetDestructor(&destruct_slacLcLpreces);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::sla::preces*)
   {
      return GenerateInitInstanceLocal((::sla::preces*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::sla::preces*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *slacLcLpreces_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::sla::preces*)0x0)->GetClass();
      slacLcLpreces_TClassManip(theClass);
   return theClass;
   }

   static void slacLcLpreces_TClassManip(TClass* theClass){
      theClass->CreateAttributeMap();
      TDictAttributeMap* attrMap( theClass->GetAttributeMap() );
      attrMap->AddProperty("file_name","sla.hh");
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *slacLcLeuler_Dictionary();
   static void slacLcLeuler_TClassManip(TClass*);
   static void delete_slacLcLeuler(void *p);
   static void deleteArray_slacLcLeuler(void *p);
   static void destruct_slacLcLeuler(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::sla::euler*)
   {
      ::sla::euler *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::sla::euler));
      static ::ROOT::TGenericClassInfo 
         instance("sla::euler", "sla.hh", 1554,
                  typeid(::sla::euler), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &slacLcLeuler_Dictionary, isa_proxy, 4,
                  sizeof(::sla::euler) );
      instance.SetDelete(&delete_slacLcLeuler);
      instance.SetDeleteArray(&deleteArray_slacLcLeuler);
      instance.SetDestructor(&destruct_slacLcLeuler);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::sla::euler*)
   {
      return GenerateInitInstanceLocal((::sla::euler*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::sla::euler*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *slacLcLeuler_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::sla::euler*)0x0)->GetClass();
      slacLcLeuler_TClassManip(theClass);
   return theClass;
   }

   static void slacLcLeuler_TClassManip(TClass* theClass){
      theClass->CreateAttributeMap();
      TDictAttributeMap* attrMap( theClass->GetAttributeMap() );
      attrMap->AddProperty("file_name","sla.hh");
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *slacLcLnutc_Dictionary();
   static void slacLcLnutc_TClassManip(TClass*);
   static void delete_slacLcLnutc(void *p);
   static void deleteArray_slacLcLnutc(void *p);
   static void destruct_slacLcLnutc(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::sla::nutc*)
   {
      ::sla::nutc *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::sla::nutc));
      static ::ROOT::TGenericClassInfo 
         instance("sla::nutc", "sla.hh", 1617,
                  typeid(::sla::nutc), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &slacLcLnutc_Dictionary, isa_proxy, 4,
                  sizeof(::sla::nutc) );
      instance.SetDelete(&delete_slacLcLnutc);
      instance.SetDeleteArray(&deleteArray_slacLcLnutc);
      instance.SetDestructor(&destruct_slacLcLnutc);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::sla::nutc*)
   {
      return GenerateInitInstanceLocal((::sla::nutc*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::sla::nutc*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *slacLcLnutc_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::sla::nutc*)0x0)->GetClass();
      slacLcLnutc_TClassManip(theClass);
   return theClass;
   }

   static void slacLcLnutc_TClassManip(TClass* theClass){
      theClass->CreateAttributeMap();
      TDictAttributeMap* attrMap( theClass->GetAttributeMap() );
      attrMap->AddProperty("file_name","sla.hh");
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *slacLcLrefco_Dictionary();
   static void slacLcLrefco_TClassManip(TClass*);
   static void delete_slacLcLrefco(void *p);
   static void deleteArray_slacLcLrefco(void *p);
   static void destruct_slacLcLrefco(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::sla::refco*)
   {
      ::sla::refco *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::sla::refco));
      static ::ROOT::TGenericClassInfo 
         instance("sla::refco", "sla.hh", 1684,
                  typeid(::sla::refco), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &slacLcLrefco_Dictionary, isa_proxy, 4,
                  sizeof(::sla::refco) );
      instance.SetDelete(&delete_slacLcLrefco);
      instance.SetDeleteArray(&deleteArray_slacLcLrefco);
      instance.SetDestructor(&destruct_slacLcLrefco);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::sla::refco*)
   {
      return GenerateInitInstanceLocal((::sla::refco*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::sla::refco*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *slacLcLrefco_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::sla::refco*)0x0)->GetClass();
      slacLcLrefco_TClassManip(theClass);
   return theClass;
   }

   static void slacLcLrefco_TClassManip(TClass* theClass){
      theClass->CreateAttributeMap();
      TDictAttributeMap* attrMap( theClass->GetAttributeMap() );
      attrMap->AddProperty("file_name","sla.hh");
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *slacLcLdvn_Dictionary();
   static void slacLcLdvn_TClassManip(TClass*);
   static void delete_slacLcLdvn(void *p);
   static void deleteArray_slacLcLdvn(void *p);
   static void destruct_slacLcLdvn(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::sla::dvn*)
   {
      ::sla::dvn *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::sla::dvn));
      static ::ROOT::TGenericClassInfo 
         instance("sla::dvn", "sla.hh", 1753,
                  typeid(::sla::dvn), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &slacLcLdvn_Dictionary, isa_proxy, 4,
                  sizeof(::sla::dvn) );
      instance.SetDelete(&delete_slacLcLdvn);
      instance.SetDeleteArray(&deleteArray_slacLcLdvn);
      instance.SetDestructor(&destruct_slacLcLdvn);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::sla::dvn*)
   {
      return GenerateInitInstanceLocal((::sla::dvn*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::sla::dvn*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *slacLcLdvn_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::sla::dvn*)0x0)->GetClass();
      slacLcLdvn_TClassManip(theClass);
   return theClass;
   }

   static void slacLcLdvn_TClassManip(TClass* theClass){
      theClass->CreateAttributeMap();
      TDictAttributeMap* attrMap( theClass->GetAttributeMap() );
      attrMap->AddProperty("file_name","sla.hh");
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *slacLcLpertel_Dictionary();
   static void slacLcLpertel_TClassManip(TClass*);
   static void delete_slacLcLpertel(void *p);
   static void deleteArray_slacLcLpertel(void *p);
   static void destruct_slacLcLpertel(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::sla::pertel*)
   {
      ::sla::pertel *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::sla::pertel));
      static ::ROOT::TGenericClassInfo 
         instance("sla::pertel", "sla.hh", 1886,
                  typeid(::sla::pertel), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &slacLcLpertel_Dictionary, isa_proxy, 4,
                  sizeof(::sla::pertel) );
      instance.SetDelete(&delete_slacLcLpertel);
      instance.SetDeleteArray(&deleteArray_slacLcLpertel);
      instance.SetDestructor(&destruct_slacLcLpertel);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::sla::pertel*)
   {
      return GenerateInitInstanceLocal((::sla::pertel*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::sla::pertel*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *slacLcLpertel_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::sla::pertel*)0x0)->GetClass();
      slacLcLpertel_TClassManip(theClass);
   return theClass;
   }

   static void slacLcLpertel_TClassManip(TClass* theClass){
      theClass->CreateAttributeMap();
      TDictAttributeMap* attrMap( theClass->GetAttributeMap() );
      attrMap->AddProperty("file_name","sla.hh");
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *slacLcLmapqkz_Dictionary();
   static void slacLcLmapqkz_TClassManip(TClass*);
   static void delete_slacLcLmapqkz(void *p);
   static void deleteArray_slacLcLmapqkz(void *p);
   static void destruct_slacLcLmapqkz(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::sla::mapqkz*)
   {
      ::sla::mapqkz *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::sla::mapqkz));
      static ::ROOT::TGenericClassInfo 
         instance("sla::mapqkz", "sla.hh", 1968,
                  typeid(::sla::mapqkz), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &slacLcLmapqkz_Dictionary, isa_proxy, 4,
                  sizeof(::sla::mapqkz) );
      instance.SetDelete(&delete_slacLcLmapqkz);
      instance.SetDeleteArray(&deleteArray_slacLcLmapqkz);
      instance.SetDestructor(&destruct_slacLcLmapqkz);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::sla::mapqkz*)
   {
      return GenerateInitInstanceLocal((::sla::mapqkz*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::sla::mapqkz*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *slacLcLmapqkz_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::sla::mapqkz*)0x0)->GetClass();
      slacLcLmapqkz_TClassManip(theClass);
   return theClass;
   }

   static void slacLcLmapqkz_TClassManip(TClass* theClass){
      theClass->CreateAttributeMap();
      TDictAttributeMap* attrMap( theClass->GetAttributeMap() );
      attrMap->AddProperty("file_name","sla.hh");
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *slacLcLmap_Dictionary();
   static void slacLcLmap_TClassManip(TClass*);
   static void delete_slacLcLmap(void *p);
   static void deleteArray_slacLcLmap(void *p);
   static void destruct_slacLcLmap(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::sla::map*)
   {
      ::sla::map *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::sla::map));
      static ::ROOT::TGenericClassInfo 
         instance("sla::map", "sla.hh", 2053,
                  typeid(::sla::map), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &slacLcLmap_Dictionary, isa_proxy, 4,
                  sizeof(::sla::map) );
      instance.SetDelete(&delete_slacLcLmap);
      instance.SetDeleteArray(&deleteArray_slacLcLmap);
      instance.SetDestructor(&destruct_slacLcLmap);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::sla::map*)
   {
      return GenerateInitInstanceLocal((::sla::map*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::sla::map*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *slacLcLmap_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::sla::map*)0x0)->GetClass();
      slacLcLmap_TClassManip(theClass);
   return theClass;
   }

   static void slacLcLmap_TClassManip(TClass* theClass){
      theClass->CreateAttributeMap();
      TDictAttributeMap* attrMap( theClass->GetAttributeMap() );
      attrMap->AddProperty("file_name","sla.hh");
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *slacLcLaoppa_Dictionary();
   static void slacLcLaoppa_TClassManip(TClass*);
   static void delete_slacLcLaoppa(void *p);
   static void deleteArray_slacLcLaoppa(void *p);
   static void destruct_slacLcLaoppa(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::sla::aoppa*)
   {
      ::sla::aoppa *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::sla::aoppa));
      static ::ROOT::TGenericClassInfo 
         instance("sla::aoppa", "sla.hh", 2180,
                  typeid(::sla::aoppa), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &slacLcLaoppa_Dictionary, isa_proxy, 4,
                  sizeof(::sla::aoppa) );
      instance.SetDelete(&delete_slacLcLaoppa);
      instance.SetDeleteArray(&deleteArray_slacLcLaoppa);
      instance.SetDestructor(&destruct_slacLcLaoppa);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::sla::aoppa*)
   {
      return GenerateInitInstanceLocal((::sla::aoppa*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::sla::aoppa*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *slacLcLaoppa_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::sla::aoppa*)0x0)->GetClass();
      slacLcLaoppa_TClassManip(theClass);
   return theClass;
   }

   static void slacLcLaoppa_TClassManip(TClass* theClass){
      theClass->CreateAttributeMap();
      TDictAttributeMap* attrMap( theClass->GetAttributeMap() );
      attrMap->AddProperty("file_name","sla.hh");
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *slacLcLpolmo_Dictionary();
   static void slacLcLpolmo_TClassManip(TClass*);
   static void delete_slacLcLpolmo(void *p);
   static void deleteArray_slacLcLpolmo(void *p);
   static void destruct_slacLcLpolmo(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::sla::polmo*)
   {
      ::sla::polmo *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::sla::polmo));
      static ::ROOT::TGenericClassInfo 
         instance("sla::polmo", "sla.hh", 2281,
                  typeid(::sla::polmo), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &slacLcLpolmo_Dictionary, isa_proxy, 4,
                  sizeof(::sla::polmo) );
      instance.SetDelete(&delete_slacLcLpolmo);
      instance.SetDeleteArray(&deleteArray_slacLcLpolmo);
      instance.SetDestructor(&destruct_slacLcLpolmo);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::sla::polmo*)
   {
      return GenerateInitInstanceLocal((::sla::polmo*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::sla::polmo*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *slacLcLpolmo_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::sla::polmo*)0x0)->GetClass();
      slacLcLpolmo_TClassManip(theClass);
   return theClass;
   }

   static void slacLcLpolmo_TClassManip(TClass* theClass){
      theClass->CreateAttributeMap();
      TDictAttributeMap* attrMap( theClass->GetAttributeMap() );
      attrMap->AddProperty("file_name","sla.hh");
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *slacLcLdmxv_Dictionary();
   static void slacLcLdmxv_TClassManip(TClass*);
   static void delete_slacLcLdmxv(void *p);
   static void deleteArray_slacLcLdmxv(void *p);
   static void destruct_slacLcLdmxv(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::sla::dmxv*)
   {
      ::sla::dmxv *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::sla::dmxv));
      static ::ROOT::TGenericClassInfo 
         instance("sla::dmxv", "sla.hh", 2328,
                  typeid(::sla::dmxv), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &slacLcLdmxv_Dictionary, isa_proxy, 4,
                  sizeof(::sla::dmxv) );
      instance.SetDelete(&delete_slacLcLdmxv);
      instance.SetDeleteArray(&deleteArray_slacLcLdmxv);
      instance.SetDestructor(&destruct_slacLcLdmxv);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::sla::dmxv*)
   {
      return GenerateInitInstanceLocal((::sla::dmxv*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::sla::dmxv*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *slacLcLdmxv_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::sla::dmxv*)0x0)->GetClass();
      slacLcLdmxv_TClassManip(theClass);
   return theClass;
   }

   static void slacLcLdmxv_TClassManip(TClass* theClass){
      theClass->CreateAttributeMap();
      TDictAttributeMap* attrMap( theClass->GetAttributeMap() );
      attrMap->AddProperty("file_name","sla.hh");
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *slacLcLdeuler_Dictionary();
   static void slacLcLdeuler_TClassManip(TClass*);
   static void delete_slacLcLdeuler(void *p);
   static void deleteArray_slacLcLdeuler(void *p);
   static void destruct_slacLcLdeuler(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::sla::deuler*)
   {
      ::sla::deuler *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::sla::deuler));
      static ::ROOT::TGenericClassInfo 
         instance("sla::deuler", "sla.hh", 2392,
                  typeid(::sla::deuler), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &slacLcLdeuler_Dictionary, isa_proxy, 4,
                  sizeof(::sla::deuler) );
      instance.SetDelete(&delete_slacLcLdeuler);
      instance.SetDeleteArray(&deleteArray_slacLcLdeuler);
      instance.SetDestructor(&destruct_slacLcLdeuler);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::sla::deuler*)
   {
      return GenerateInitInstanceLocal((::sla::deuler*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::sla::deuler*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *slacLcLdeuler_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::sla::deuler*)0x0)->GetClass();
      slacLcLdeuler_TClassManip(theClass);
   return theClass;
   }

   static void slacLcLdeuler_TClassManip(TClass* theClass){
      theClass->CreateAttributeMap();
      TDictAttributeMap* attrMap( theClass->GetAttributeMap() );
      attrMap->AddProperty("file_name","sla.hh");
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *slacLcLcs2c_Dictionary();
   static void slacLcLcs2c_TClassManip(TClass*);
   static void delete_slacLcLcs2c(void *p);
   static void deleteArray_slacLcLcs2c(void *p);
   static void destruct_slacLcLcs2c(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::sla::cs2c*)
   {
      ::sla::cs2c *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::sla::cs2c));
      static ::ROOT::TGenericClassInfo 
         instance("sla::cs2c", "sla.hh", 2436,
                  typeid(::sla::cs2c), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &slacLcLcs2c_Dictionary, isa_proxy, 4,
                  sizeof(::sla::cs2c) );
      instance.SetDelete(&delete_slacLcLcs2c);
      instance.SetDeleteArray(&deleteArray_slacLcLcs2c);
      instance.SetDestructor(&destruct_slacLcLcs2c);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::sla::cs2c*)
   {
      return GenerateInitInstanceLocal((::sla::cs2c*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::sla::cs2c*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *slacLcLcs2c_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::sla::cs2c*)0x0)->GetClass();
      slacLcLcs2c_TClassManip(theClass);
   return theClass;
   }

   static void slacLcLcs2c_TClassManip(TClass* theClass){
      theClass->CreateAttributeMap();
      TDictAttributeMap* attrMap( theClass->GetAttributeMap() );
      attrMap->AddProperty("file_name","sla.hh");
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *slacLcLimxv_Dictionary();
   static void slacLcLimxv_TClassManip(TClass*);
   static void delete_slacLcLimxv(void *p);
   static void deleteArray_slacLcLimxv(void *p);
   static void destruct_slacLcLimxv(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::sla::imxv*)
   {
      ::sla::imxv *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::sla::imxv));
      static ::ROOT::TGenericClassInfo 
         instance("sla::imxv", "sla.hh", 2482,
                  typeid(::sla::imxv), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &slacLcLimxv_Dictionary, isa_proxy, 4,
                  sizeof(::sla::imxv) );
      instance.SetDelete(&delete_slacLcLimxv);
      instance.SetDeleteArray(&deleteArray_slacLcLimxv);
      instance.SetDestructor(&destruct_slacLcLimxv);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::sla::imxv*)
   {
      return GenerateInitInstanceLocal((::sla::imxv*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::sla::imxv*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *slacLcLimxv_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::sla::imxv*)0x0)->GetClass();
      slacLcLimxv_TClassManip(theClass);
   return theClass;
   }

   static void slacLcLimxv_TClassManip(TClass* theClass){
      theClass->CreateAttributeMap();
      TDictAttributeMap* attrMap( theClass->GetAttributeMap() );
      attrMap->AddProperty("file_name","sla.hh");
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *slacLcLfk5hz_Dictionary();
   static void slacLcLfk5hz_TClassManip(TClass*);
   static void delete_slacLcLfk5hz(void *p);
   static void deleteArray_slacLcLfk5hz(void *p);
   static void destruct_slacLcLfk5hz(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::sla::fk5hz*)
   {
      ::sla::fk5hz *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::sla::fk5hz));
      static ::ROOT::TGenericClassInfo 
         instance("sla::fk5hz", "sla.hh", 2551,
                  typeid(::sla::fk5hz), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &slacLcLfk5hz_Dictionary, isa_proxy, 4,
                  sizeof(::sla::fk5hz) );
      instance.SetDelete(&delete_slacLcLfk5hz);
      instance.SetDeleteArray(&deleteArray_slacLcLfk5hz);
      instance.SetDestructor(&destruct_slacLcLfk5hz);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::sla::fk5hz*)
   {
      return GenerateInitInstanceLocal((::sla::fk5hz*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::sla::fk5hz*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *slacLcLfk5hz_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::sla::fk5hz*)0x0)->GetClass();
      slacLcLfk5hz_TClassManip(theClass);
   return theClass;
   }

   static void slacLcLfk5hz_TClassManip(TClass* theClass){
      theClass->CreateAttributeMap();
      TDictAttributeMap* attrMap( theClass->GetAttributeMap() );
      attrMap->AddProperty("file_name","sla.hh");
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *slacLcLdcc2s_Dictionary();
   static void slacLcLdcc2s_TClassManip(TClass*);
   static void delete_slacLcLdcc2s(void *p);
   static void deleteArray_slacLcLdcc2s(void *p);
   static void destruct_slacLcLdcc2s(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::sla::dcc2s*)
   {
      ::sla::dcc2s *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::sla::dcc2s));
      static ::ROOT::TGenericClassInfo 
         instance("sla::dcc2s", "sla.hh", 2619,
                  typeid(::sla::dcc2s), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &slacLcLdcc2s_Dictionary, isa_proxy, 4,
                  sizeof(::sla::dcc2s) );
      instance.SetDelete(&delete_slacLcLdcc2s);
      instance.SetDeleteArray(&deleteArray_slacLcLdcc2s);
      instance.SetDestructor(&destruct_slacLcLdcc2s);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::sla::dcc2s*)
   {
      return GenerateInitInstanceLocal((::sla::dcc2s*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::sla::dcc2s*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *slacLcLdcc2s_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::sla::dcc2s*)0x0)->GetClass();
      slacLcLdcc2s_TClassManip(theClass);
   return theClass;
   }

   static void slacLcLdcc2s_TClassManip(TClass* theClass){
      theClass->CreateAttributeMap();
      TDictAttributeMap* attrMap( theClass->GetAttributeMap() );
      attrMap->AddProperty("file_name","sla.hh");
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *slacLcLrefro_Dictionary();
   static void slacLcLrefro_TClassManip(TClass*);
   static void delete_slacLcLrefro(void *p);
   static void deleteArray_slacLcLrefro(void *p);
   static void destruct_slacLcLrefro(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::sla::refro*)
   {
      ::sla::refro *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::sla::refro));
      static ::ROOT::TGenericClassInfo 
         instance("sla::refro", "sla.hh", 2764,
                  typeid(::sla::refro), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &slacLcLrefro_Dictionary, isa_proxy, 4,
                  sizeof(::sla::refro) );
      instance.SetDelete(&delete_slacLcLrefro);
      instance.SetDeleteArray(&deleteArray_slacLcLrefro);
      instance.SetDestructor(&destruct_slacLcLrefro);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::sla::refro*)
   {
      return GenerateInitInstanceLocal((::sla::refro*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::sla::refro*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *slacLcLrefro_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::sla::refro*)0x0)->GetClass();
      slacLcLrefro_TClassManip(theClass);
   return theClass;
   }

   static void slacLcLrefro_TClassManip(TClass* theClass){
      theClass->CreateAttributeMap();
      TDictAttributeMap* attrMap( theClass->GetAttributeMap() );
      attrMap->AddProperty("file_name","sla.hh");
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *slacLcLav2m_Dictionary();
   static void slacLcLav2m_TClassManip(TClass*);
   static void delete_slacLcLav2m(void *p);
   static void deleteArray_slacLcLav2m(void *p);
   static void destruct_slacLcLav2m(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::sla::av2m*)
   {
      ::sla::av2m *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::sla::av2m));
      static ::ROOT::TGenericClassInfo 
         instance("sla::av2m", "sla.hh", 2814,
                  typeid(::sla::av2m), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &slacLcLav2m_Dictionary, isa_proxy, 4,
                  sizeof(::sla::av2m) );
      instance.SetDelete(&delete_slacLcLav2m);
      instance.SetDeleteArray(&deleteArray_slacLcLav2m);
      instance.SetDestructor(&destruct_slacLcLav2m);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::sla::av2m*)
   {
      return GenerateInitInstanceLocal((::sla::av2m*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::sla::av2m*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *slacLcLav2m_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::sla::av2m*)0x0)->GetClass();
      slacLcLav2m_TClassManip(theClass);
   return theClass;
   }

   static void slacLcLav2m_TClassManip(TClass* theClass){
      theClass->CreateAttributeMap();
      TDictAttributeMap* attrMap( theClass->GetAttributeMap() );
      attrMap->AddProperty("file_name","sla.hh");
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *slacLcLel2ue_Dictionary();
   static void slacLcLel2ue_TClassManip(TClass*);
   static void delete_slacLcLel2ue(void *p);
   static void deleteArray_slacLcLel2ue(void *p);
   static void destruct_slacLcLel2ue(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::sla::el2ue*)
   {
      ::sla::el2ue *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::sla::el2ue));
      static ::ROOT::TGenericClassInfo 
         instance("sla::el2ue", "sla.hh", 2960,
                  typeid(::sla::el2ue), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &slacLcLel2ue_Dictionary, isa_proxy, 4,
                  sizeof(::sla::el2ue) );
      instance.SetDelete(&delete_slacLcLel2ue);
      instance.SetDeleteArray(&deleteArray_slacLcLel2ue);
      instance.SetDestructor(&destruct_slacLcLel2ue);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::sla::el2ue*)
   {
      return GenerateInitInstanceLocal((::sla::el2ue*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::sla::el2ue*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *slacLcLel2ue_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::sla::el2ue*)0x0)->GetClass();
      slacLcLel2ue_TClassManip(theClass);
   return theClass;
   }

   static void slacLcLel2ue_TClassManip(TClass* theClass){
      theClass->CreateAttributeMap();
      TDictAttributeMap* attrMap( theClass->GetAttributeMap() );
      attrMap->AddProperty("file_name","sla.hh");
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *slacLcLcr2af_Dictionary();
   static void slacLcLcr2af_TClassManip(TClass*);
   static void delete_slacLcLcr2af(void *p);
   static void deleteArray_slacLcLcr2af(void *p);
   static void destruct_slacLcLcr2af(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::sla::cr2af*)
   {
      ::sla::cr2af *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::sla::cr2af));
      static ::ROOT::TGenericClassInfo 
         instance("sla::cr2af", "sla.hh", 3020,
                  typeid(::sla::cr2af), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &slacLcLcr2af_Dictionary, isa_proxy, 4,
                  sizeof(::sla::cr2af) );
      instance.SetDelete(&delete_slacLcLcr2af);
      instance.SetDeleteArray(&deleteArray_slacLcLcr2af);
      instance.SetDestructor(&destruct_slacLcLcr2af);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::sla::cr2af*)
   {
      return GenerateInitInstanceLocal((::sla::cr2af*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::sla::cr2af*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *slacLcLcr2af_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::sla::cr2af*)0x0)->GetClass();
      slacLcLcr2af_TClassManip(theClass);
   return theClass;
   }

   static void slacLcLcr2af_TClassManip(TClass* theClass){
      theClass->CreateAttributeMap();
      TDictAttributeMap* attrMap( theClass->GetAttributeMap() );
      attrMap->AddProperty("file_name","sla.hh");
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *slacLcLecleq_Dictionary();
   static void slacLcLecleq_TClassManip(TClass*);
   static void delete_slacLcLecleq(void *p);
   static void deleteArray_slacLcLecleq(void *p);
   static void destruct_slacLcLecleq(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::sla::ecleq*)
   {
      ::sla::ecleq *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::sla::ecleq));
      static ::ROOT::TGenericClassInfo 
         instance("sla::ecleq", "sla.hh", 3065,
                  typeid(::sla::ecleq), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &slacLcLecleq_Dictionary, isa_proxy, 4,
                  sizeof(::sla::ecleq) );
      instance.SetDelete(&delete_slacLcLecleq);
      instance.SetDeleteArray(&deleteArray_slacLcLecleq);
      instance.SetDestructor(&destruct_slacLcLecleq);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::sla::ecleq*)
   {
      return GenerateInitInstanceLocal((::sla::ecleq*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::sla::ecleq*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *slacLcLecleq_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::sla::ecleq*)0x0)->GetClass();
      slacLcLecleq_TClassManip(theClass);
   return theClass;
   }

   static void slacLcLecleq_TClassManip(TClass* theClass){
      theClass->CreateAttributeMap();
      TDictAttributeMap* attrMap( theClass->GetAttributeMap() );
      attrMap->AddProperty("file_name","sla.hh");
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *slacLcLmappa_Dictionary();
   static void slacLcLmappa_TClassManip(TClass*);
   static void delete_slacLcLmappa(void *p);
   static void deleteArray_slacLcLmappa(void *p);
   static void destruct_slacLcLmappa(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::sla::mappa*)
   {
      ::sla::mappa *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::sla::mappa));
      static ::ROOT::TGenericClassInfo 
         instance("sla::mappa", "sla.hh", 3152,
                  typeid(::sla::mappa), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &slacLcLmappa_Dictionary, isa_proxy, 4,
                  sizeof(::sla::mappa) );
      instance.SetDelete(&delete_slacLcLmappa);
      instance.SetDeleteArray(&deleteArray_slacLcLmappa);
      instance.SetDestructor(&destruct_slacLcLmappa);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::sla::mappa*)
   {
      return GenerateInitInstanceLocal((::sla::mappa*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::sla::mappa*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *slacLcLmappa_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::sla::mappa*)0x0)->GetClass();
      slacLcLmappa_TClassManip(theClass);
   return theClass;
   }

   static void slacLcLmappa_TClassManip(TClass* theClass){
      theClass->CreateAttributeMap();
      TDictAttributeMap* attrMap( theClass->GetAttributeMap() );
      attrMap->AddProperty("file_name","sla.hh");
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *slacLcLctf2d_Dictionary();
   static void slacLcLctf2d_TClassManip(TClass*);
   static void delete_slacLcLctf2d(void *p);
   static void deleteArray_slacLcLctf2d(void *p);
   static void destruct_slacLcLctf2d(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::sla::ctf2d*)
   {
      ::sla::ctf2d *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::sla::ctf2d));
      static ::ROOT::TGenericClassInfo 
         instance("sla::ctf2d", "sla.hh", 3203,
                  typeid(::sla::ctf2d), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &slacLcLctf2d_Dictionary, isa_proxy, 4,
                  sizeof(::sla::ctf2d) );
      instance.SetDelete(&delete_slacLcLctf2d);
      instance.SetDeleteArray(&deleteArray_slacLcLctf2d);
      instance.SetDestructor(&destruct_slacLcLctf2d);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::sla::ctf2d*)
   {
      return GenerateInitInstanceLocal((::sla::ctf2d*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::sla::ctf2d*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *slacLcLctf2d_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::sla::ctf2d*)0x0)->GetClass();
      slacLcLctf2d_TClassManip(theClass);
   return theClass;
   }

   static void slacLcLctf2d_TClassManip(TClass* theClass){
      theClass->CreateAttributeMap();
      TDictAttributeMap* attrMap( theClass->GetAttributeMap() );
      attrMap->AddProperty("file_name","sla.hh");
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *slacLcLunpcd_Dictionary();
   static void slacLcLunpcd_TClassManip(TClass*);
   static void delete_slacLcLunpcd(void *p);
   static void deleteArray_slacLcLunpcd(void *p);
   static void destruct_slacLcLunpcd(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::sla::unpcd*)
   {
      ::sla::unpcd *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::sla::unpcd));
      static ::ROOT::TGenericClassInfo 
         instance("sla::unpcd", "sla.hh", 3276,
                  typeid(::sla::unpcd), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &slacLcLunpcd_Dictionary, isa_proxy, 4,
                  sizeof(::sla::unpcd) );
      instance.SetDelete(&delete_slacLcLunpcd);
      instance.SetDeleteArray(&deleteArray_slacLcLunpcd);
      instance.SetDestructor(&destruct_slacLcLunpcd);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::sla::unpcd*)
   {
      return GenerateInitInstanceLocal((::sla::unpcd*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::sla::unpcd*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *slacLcLunpcd_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::sla::unpcd*)0x0)->GetClass();
      slacLcLunpcd_TClassManip(theClass);
   return theClass;
   }

   static void slacLcLunpcd_TClassManip(TClass* theClass){
      theClass->CreateAttributeMap();
      TDictAttributeMap* attrMap( theClass->GetAttributeMap() );
      attrMap->AddProperty("file_name","sla.hh");
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *slacLcLcd2tf_Dictionary();
   static void slacLcLcd2tf_TClassManip(TClass*);
   static void delete_slacLcLcd2tf(void *p);
   static void deleteArray_slacLcLcd2tf(void *p);
   static void destruct_slacLcLcd2tf(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::sla::cd2tf*)
   {
      ::sla::cd2tf *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::sla::cd2tf));
      static ::ROOT::TGenericClassInfo 
         instance("sla::cd2tf", "sla.hh", 3337,
                  typeid(::sla::cd2tf), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &slacLcLcd2tf_Dictionary, isa_proxy, 4,
                  sizeof(::sla::cd2tf) );
      instance.SetDelete(&delete_slacLcLcd2tf);
      instance.SetDeleteArray(&deleteArray_slacLcLcd2tf);
      instance.SetDestructor(&destruct_slacLcLcd2tf);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::sla::cd2tf*)
   {
      return GenerateInitInstanceLocal((::sla::cd2tf*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::sla::cd2tf*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *slacLcLcd2tf_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::sla::cd2tf*)0x0)->GetClass();
      slacLcLcd2tf_TClassManip(theClass);
   return theClass;
   }

   static void slacLcLcd2tf_TClassManip(TClass* theClass){
      theClass->CreateAttributeMap();
      TDictAttributeMap* attrMap( theClass->GetAttributeMap() );
      attrMap->AddProperty("file_name","sla.hh");
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *slacLcLmxm_Dictionary();
   static void slacLcLmxm_TClassManip(TClass*);
   static void delete_slacLcLmxm(void *p);
   static void deleteArray_slacLcLmxm(void *p);
   static void destruct_slacLcLmxm(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::sla::mxm*)
   {
      ::sla::mxm *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::sla::mxm));
      static ::ROOT::TGenericClassInfo 
         instance("sla::mxm", "sla.hh", 3383,
                  typeid(::sla::mxm), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &slacLcLmxm_Dictionary, isa_proxy, 4,
                  sizeof(::sla::mxm) );
      instance.SetDelete(&delete_slacLcLmxm);
      instance.SetDeleteArray(&deleteArray_slacLcLmxm);
      instance.SetDestructor(&destruct_slacLcLmxm);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::sla::mxm*)
   {
      return GenerateInitInstanceLocal((::sla::mxm*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::sla::mxm*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *slacLcLmxm_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::sla::mxm*)0x0)->GetClass();
      slacLcLmxm_TClassManip(theClass);
   return theClass;
   }

   static void slacLcLmxm_TClassManip(TClass* theClass){
      theClass->CreateAttributeMap();
      TDictAttributeMap* attrMap( theClass->GetAttributeMap() );
      attrMap->AddProperty("file_name","sla.hh");
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *slacLcLdfltin_Dictionary();
   static void slacLcLdfltin_TClassManip(TClass*);
   static void delete_slacLcLdfltin(void *p);
   static void deleteArray_slacLcLdfltin(void *p);
   static void destruct_slacLcLdfltin(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::sla::dfltin*)
   {
      ::sla::dfltin *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::sla::dfltin));
      static ::ROOT::TGenericClassInfo 
         instance("sla::dfltin", "sla.hh", 3515,
                  typeid(::sla::dfltin), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &slacLcLdfltin_Dictionary, isa_proxy, 4,
                  sizeof(::sla::dfltin) );
      instance.SetDelete(&delete_slacLcLdfltin);
      instance.SetDeleteArray(&deleteArray_slacLcLdfltin);
      instance.SetDestructor(&destruct_slacLcLdfltin);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::sla::dfltin*)
   {
      return GenerateInitInstanceLocal((::sla::dfltin*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::sla::dfltin*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *slacLcLdfltin_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::sla::dfltin*)0x0)->GetClass();
      slacLcLdfltin_TClassManip(theClass);
   return theClass;
   }

   static void slacLcLdfltin_TClassManip(TClass* theClass){
      theClass->CreateAttributeMap();
      TDictAttributeMap* attrMap( theClass->GetAttributeMap() );
      attrMap->AddProperty("file_name","sla.hh");
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *slacLcLplantu_Dictionary();
   static void slacLcLplantu_TClassManip(TClass*);
   static void delete_slacLcLplantu(void *p);
   static void deleteArray_slacLcLplantu(void *p);
   static void destruct_slacLcLplantu(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::sla::plantu*)
   {
      ::sla::plantu *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::sla::plantu));
      static ::ROOT::TGenericClassInfo 
         instance("sla::plantu", "sla.hh", 3608,
                  typeid(::sla::plantu), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &slacLcLplantu_Dictionary, isa_proxy, 4,
                  sizeof(::sla::plantu) );
      instance.SetDelete(&delete_slacLcLplantu);
      instance.SetDeleteArray(&deleteArray_slacLcLplantu);
      instance.SetDestructor(&destruct_slacLcLplantu);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::sla::plantu*)
   {
      return GenerateInitInstanceLocal((::sla::plantu*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::sla::plantu*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *slacLcLplantu_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::sla::plantu*)0x0)->GetClass();
      slacLcLplantu_TClassManip(theClass);
   return theClass;
   }

   static void slacLcLplantu_TClassManip(TClass* theClass){
      theClass->CreateAttributeMap();
      TDictAttributeMap* attrMap( theClass->GetAttributeMap() );
      attrMap->AddProperty("file_name","sla.hh");
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *slacLcLdvxv_Dictionary();
   static void slacLcLdvxv_TClassManip(TClass*);
   static void delete_slacLcLdvxv(void *p);
   static void deleteArray_slacLcLdvxv(void *p);
   static void destruct_slacLcLdvxv(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::sla::dvxv*)
   {
      ::sla::dvxv *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::sla::dvxv));
      static ::ROOT::TGenericClassInfo 
         instance("sla::dvxv", "sla.hh", 3685,
                  typeid(::sla::dvxv), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &slacLcLdvxv_Dictionary, isa_proxy, 4,
                  sizeof(::sla::dvxv) );
      instance.SetDelete(&delete_slacLcLdvxv);
      instance.SetDeleteArray(&deleteArray_slacLcLdvxv);
      instance.SetDestructor(&destruct_slacLcLdvxv);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::sla::dvxv*)
   {
      return GenerateInitInstanceLocal((::sla::dvxv*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::sla::dvxv*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *slacLcLdvxv_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::sla::dvxv*)0x0)->GetClass();
      slacLcLdvxv_TClassManip(theClass);
   return theClass;
   }

   static void slacLcLdvxv_TClassManip(TClass* theClass){
      theClass->CreateAttributeMap();
      TDictAttributeMap* attrMap( theClass->GetAttributeMap() );
      attrMap->AddProperty("file_name","sla.hh");
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *slacLcLaltaz_Dictionary();
   static void slacLcLaltaz_TClassManip(TClass*);
   static void delete_slacLcLaltaz(void *p);
   static void deleteArray_slacLcLaltaz(void *p);
   static void destruct_slacLcLaltaz(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::sla::altaz*)
   {
      ::sla::altaz *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::sla::altaz));
      static ::ROOT::TGenericClassInfo 
         instance("sla::altaz", "sla.hh", 3777,
                  typeid(::sla::altaz), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &slacLcLaltaz_Dictionary, isa_proxy, 4,
                  sizeof(::sla::altaz) );
      instance.SetDelete(&delete_slacLcLaltaz);
      instance.SetDeleteArray(&deleteArray_slacLcLaltaz);
      instance.SetDestructor(&destruct_slacLcLaltaz);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::sla::altaz*)
   {
      return GenerateInitInstanceLocal((::sla::altaz*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::sla::altaz*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *slacLcLaltaz_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::sla::altaz*)0x0)->GetClass();
      slacLcLaltaz_TClassManip(theClass);
   return theClass;
   }

   static void slacLcLaltaz_TClassManip(TClass* theClass){
      theClass->CreateAttributeMap();
      TDictAttributeMap* attrMap( theClass->GetAttributeMap() );
      attrMap->AddProperty("file_name","sla.hh");
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *slacLcLdav2m_Dictionary();
   static void slacLcLdav2m_TClassManip(TClass*);
   static void delete_slacLcLdav2m(void *p);
   static void deleteArray_slacLcLdav2m(void *p);
   static void destruct_slacLcLdav2m(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::sla::dav2m*)
   {
      ::sla::dav2m *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::sla::dav2m));
      static ::ROOT::TGenericClassInfo 
         instance("sla::dav2m", "sla.hh", 3826,
                  typeid(::sla::dav2m), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &slacLcLdav2m_Dictionary, isa_proxy, 4,
                  sizeof(::sla::dav2m) );
      instance.SetDelete(&delete_slacLcLdav2m);
      instance.SetDeleteArray(&deleteArray_slacLcLdav2m);
      instance.SetDestructor(&destruct_slacLcLdav2m);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::sla::dav2m*)
   {
      return GenerateInitInstanceLocal((::sla::dav2m*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::sla::dav2m*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *slacLcLdav2m_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::sla::dav2m*)0x0)->GetClass();
      slacLcLdav2m_TClassManip(theClass);
   return theClass;
   }

   static void slacLcLdav2m_TClassManip(TClass* theClass){
      theClass->CreateAttributeMap();
      TDictAttributeMap* attrMap( theClass->GetAttributeMap() );
      attrMap->AddProperty("file_name","sla.hh");
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *slacLcLde2h_Dictionary();
   static void slacLcLde2h_TClassManip(TClass*);
   static void delete_slacLcLde2h(void *p);
   static void deleteArray_slacLcLde2h(void *p);
   static void destruct_slacLcLde2h(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::sla::de2h*)
   {
      ::sla::de2h *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::sla::de2h));
      static ::ROOT::TGenericClassInfo 
         instance("sla::de2h", "sla.hh", 3899,
                  typeid(::sla::de2h), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &slacLcLde2h_Dictionary, isa_proxy, 4,
                  sizeof(::sla::de2h) );
      instance.SetDelete(&delete_slacLcLde2h);
      instance.SetDeleteArray(&deleteArray_slacLcLde2h);
      instance.SetDestructor(&destruct_slacLcLde2h);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::sla::de2h*)
   {
      return GenerateInitInstanceLocal((::sla::de2h*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::sla::de2h*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *slacLcLde2h_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::sla::de2h*)0x0)->GetClass();
      slacLcLde2h_TClassManip(theClass);
   return theClass;
   }

   static void slacLcLde2h_TClassManip(TClass* theClass){
      theClass->CreateAttributeMap();
      TDictAttributeMap* attrMap( theClass->GetAttributeMap() );
      attrMap->AddProperty("file_name","sla.hh");
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *slacLcLmoon_Dictionary();
   static void slacLcLmoon_TClassManip(TClass*);
   static void delete_slacLcLmoon(void *p);
   static void deleteArray_slacLcLmoon(void *p);
   static void destruct_slacLcLmoon(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::sla::moon*)
   {
      ::sla::moon *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::sla::moon));
      static ::ROOT::TGenericClassInfo 
         instance("sla::moon", "sla.hh", 4021,
                  typeid(::sla::moon), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &slacLcLmoon_Dictionary, isa_proxy, 4,
                  sizeof(::sla::moon) );
      instance.SetDelete(&delete_slacLcLmoon);
      instance.SetDeleteArray(&deleteArray_slacLcLmoon);
      instance.SetDestructor(&destruct_slacLcLmoon);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::sla::moon*)
   {
      return GenerateInitInstanceLocal((::sla::moon*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::sla::moon*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *slacLcLmoon_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::sla::moon*)0x0)->GetClass();
      slacLcLmoon_TClassManip(theClass);
   return theClass;
   }

   static void slacLcLmoon_TClassManip(TClass* theClass){
      theClass->CreateAttributeMap();
      TDictAttributeMap* attrMap( theClass->GetAttributeMap() );
      attrMap->AddProperty("file_name","sla.hh");
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *slacLcLdd2tf_Dictionary();
   static void slacLcLdd2tf_TClassManip(TClass*);
   static void delete_slacLcLdd2tf(void *p);
   static void deleteArray_slacLcLdd2tf(void *p);
   static void destruct_slacLcLdd2tf(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::sla::dd2tf*)
   {
      ::sla::dd2tf *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::sla::dd2tf));
      static ::ROOT::TGenericClassInfo 
         instance("sla::dd2tf", "sla.hh", 4101,
                  typeid(::sla::dd2tf), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &slacLcLdd2tf_Dictionary, isa_proxy, 4,
                  sizeof(::sla::dd2tf) );
      instance.SetDelete(&delete_slacLcLdd2tf);
      instance.SetDeleteArray(&deleteArray_slacLcLdd2tf);
      instance.SetDestructor(&destruct_slacLcLdd2tf);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::sla::dd2tf*)
   {
      return GenerateInitInstanceLocal((::sla::dd2tf*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::sla::dd2tf*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *slacLcLdd2tf_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::sla::dd2tf*)0x0)->GetClass();
      slacLcLdd2tf_TClassManip(theClass);
   return theClass;
   }

   static void slacLcLdd2tf_TClassManip(TClass* theClass){
      theClass->CreateAttributeMap();
      TDictAttributeMap* attrMap( theClass->GetAttributeMap() );
      attrMap->AddProperty("file_name","sla.hh");
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *slacLcLgaleq_Dictionary();
   static void slacLcLgaleq_TClassManip(TClass*);
   static void delete_slacLcLgaleq(void *p);
   static void deleteArray_slacLcLgaleq(void *p);
   static void destruct_slacLcLgaleq(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::sla::galeq*)
   {
      ::sla::galeq *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::sla::galeq));
      static ::ROOT::TGenericClassInfo 
         instance("sla::galeq", "sla.hh", 4153,
                  typeid(::sla::galeq), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &slacLcLgaleq_Dictionary, isa_proxy, 4,
                  sizeof(::sla::galeq) );
      instance.SetDelete(&delete_slacLcLgaleq);
      instance.SetDeleteArray(&deleteArray_slacLcLgaleq);
      instance.SetDestructor(&destruct_slacLcLgaleq);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::sla::galeq*)
   {
      return GenerateInitInstanceLocal((::sla::galeq*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::sla::galeq*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *slacLcLgaleq_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::sla::galeq*)0x0)->GetClass();
      slacLcLgaleq_TClassManip(theClass);
   return theClass;
   }

   static void slacLcLgaleq_TClassManip(TClass* theClass){
      theClass->CreateAttributeMap();
      TDictAttributeMap* attrMap( theClass->GetAttributeMap() );
      attrMap->AddProperty("file_name","sla.hh");
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *slacLcLoap_Dictionary();
   static void slacLcLoap_TClassManip(TClass*);
   static void delete_slacLcLoap(void *p);
   static void deleteArray_slacLcLoap(void *p);
   static void destruct_slacLcLoap(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::sla::oap*)
   {
      ::sla::oap *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::sla::oap));
      static ::ROOT::TGenericClassInfo 
         instance("sla::oap", "sla.hh", 4331,
                  typeid(::sla::oap), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &slacLcLoap_Dictionary, isa_proxy, 4,
                  sizeof(::sla::oap) );
      instance.SetDelete(&delete_slacLcLoap);
      instance.SetDeleteArray(&deleteArray_slacLcLoap);
      instance.SetDestructor(&destruct_slacLcLoap);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::sla::oap*)
   {
      return GenerateInitInstanceLocal((::sla::oap*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::sla::oap*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *slacLcLoap_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::sla::oap*)0x0)->GetClass();
      slacLcLoap_TClassManip(theClass);
   return theClass;
   }

   static void slacLcLoap_TClassManip(TClass* theClass){
      theClass->CreateAttributeMap();
      TDictAttributeMap* attrMap( theClass->GetAttributeMap() );
      attrMap->AddProperty("file_name","sla.hh");
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *slacLcLnutc80_Dictionary();
   static void slacLcLnutc80_TClassManip(TClass*);
   static void delete_slacLcLnutc80(void *p);
   static void deleteArray_slacLcLnutc80(void *p);
   static void destruct_slacLcLnutc80(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::sla::nutc80*)
   {
      ::sla::nutc80 *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::sla::nutc80));
      static ::ROOT::TGenericClassInfo 
         instance("sla::nutc80", "sla.hh", 4392,
                  typeid(::sla::nutc80), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &slacLcLnutc80_Dictionary, isa_proxy, 4,
                  sizeof(::sla::nutc80) );
      instance.SetDelete(&delete_slacLcLnutc80);
      instance.SetDeleteArray(&deleteArray_slacLcLnutc80);
      instance.SetDestructor(&destruct_slacLcLnutc80);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::sla::nutc80*)
   {
      return GenerateInitInstanceLocal((::sla::nutc80*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::sla::nutc80*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *slacLcLnutc80_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::sla::nutc80*)0x0)->GetClass();
      slacLcLnutc80_TClassManip(theClass);
   return theClass;
   }

   static void slacLcLnutc80_TClassManip(TClass* theClass){
      theClass->CreateAttributeMap();
      TDictAttributeMap* attrMap( theClass->GetAttributeMap() );
      attrMap->AddProperty("file_name","sla.hh");
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *slacLcLplanel_Dictionary();
   static void slacLcLplanel_TClassManip(TClass*);
   static void delete_slacLcLplanel(void *p);
   static void deleteArray_slacLcLplanel(void *p);
   static void destruct_slacLcLplanel(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::sla::planel*)
   {
      ::sla::planel *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::sla::planel));
      static ::ROOT::TGenericClassInfo 
         instance("sla::planel", "sla.hh", 4550,
                  typeid(::sla::planel), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &slacLcLplanel_Dictionary, isa_proxy, 4,
                  sizeof(::sla::planel) );
      instance.SetDelete(&delete_slacLcLplanel);
      instance.SetDeleteArray(&deleteArray_slacLcLplanel);
      instance.SetDestructor(&destruct_slacLcLplanel);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::sla::planel*)
   {
      return GenerateInitInstanceLocal((::sla::planel*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::sla::planel*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *slacLcLplanel_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::sla::planel*)0x0)->GetClass();
      slacLcLplanel_TClassManip(theClass);
   return theClass;
   }

   static void slacLcLplanel_TClassManip(TClass* theClass){
      theClass->CreateAttributeMap();
      TDictAttributeMap* attrMap( theClass->GetAttributeMap() );
      attrMap->AddProperty("file_name","sla.hh");
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *slacLcLh2fk5_Dictionary();
   static void slacLcLh2fk5_TClassManip(TClass*);
   static void delete_slacLcLh2fk5(void *p);
   static void deleteArray_slacLcLh2fk5(void *p);
   static void destruct_slacLcLh2fk5(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::sla::h2fk5*)
   {
      ::sla::h2fk5 *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::sla::h2fk5));
      static ::ROOT::TGenericClassInfo 
         instance("sla::h2fk5", "sla.hh", 4621,
                  typeid(::sla::h2fk5), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &slacLcLh2fk5_Dictionary, isa_proxy, 4,
                  sizeof(::sla::h2fk5) );
      instance.SetDelete(&delete_slacLcLh2fk5);
      instance.SetDeleteArray(&deleteArray_slacLcLh2fk5);
      instance.SetDestructor(&destruct_slacLcLh2fk5);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::sla::h2fk5*)
   {
      return GenerateInitInstanceLocal((::sla::h2fk5*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::sla::h2fk5*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *slacLcLh2fk5_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::sla::h2fk5*)0x0)->GetClass();
      slacLcLh2fk5_TClassManip(theClass);
   return theClass;
   }

   static void slacLcLh2fk5_TClassManip(TClass* theClass){
      theClass->CreateAttributeMap();
      TDictAttributeMap* attrMap( theClass->GetAttributeMap() );
      attrMap->AddProperty("file_name","sla.hh");
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *slacLcLdmxm_Dictionary();
   static void slacLcLdmxm_TClassManip(TClass*);
   static void delete_slacLcLdmxm(void *p);
   static void deleteArray_slacLcLdmxm(void *p);
   static void destruct_slacLcLdmxm(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::sla::dmxm*)
   {
      ::sla::dmxm *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::sla::dmxm));
      static ::ROOT::TGenericClassInfo 
         instance("sla::dmxm", "sla.hh", 4668,
                  typeid(::sla::dmxm), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &slacLcLdmxm_Dictionary, isa_proxy, 4,
                  sizeof(::sla::dmxm) );
      instance.SetDelete(&delete_slacLcLdmxm);
      instance.SetDeleteArray(&deleteArray_slacLcLdmxm);
      instance.SetDestructor(&destruct_slacLcLdmxm);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::sla::dmxm*)
   {
      return GenerateInitInstanceLocal((::sla::dmxm*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::sla::dmxm*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *slacLcLdmxm_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::sla::dmxm*)0x0)->GetClass();
      slacLcLdmxm_TClassManip(theClass);
   return theClass;
   }

   static void slacLcLdmxm_TClassManip(TClass* theClass){
      theClass->CreateAttributeMap();
      TDictAttributeMap* attrMap( theClass->GetAttributeMap() );
      attrMap->AddProperty("file_name","sla.hh");
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *slacLcLvn_Dictionary();
   static void slacLcLvn_TClassManip(TClass*);
   static void delete_slacLcLvn(void *p);
   static void deleteArray_slacLcLvn(void *p);
   static void destruct_slacLcLvn(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::sla::vn*)
   {
      ::sla::vn *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::sla::vn));
      static ::ROOT::TGenericClassInfo 
         instance("sla::vn", "sla.hh", 4709,
                  typeid(::sla::vn), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &slacLcLvn_Dictionary, isa_proxy, 4,
                  sizeof(::sla::vn) );
      instance.SetDelete(&delete_slacLcLvn);
      instance.SetDeleteArray(&deleteArray_slacLcLvn);
      instance.SetDestructor(&destruct_slacLcLvn);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::sla::vn*)
   {
      return GenerateInitInstanceLocal((::sla::vn*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::sla::vn*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *slacLcLvn_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::sla::vn*)0x0)->GetClass();
      slacLcLvn_TClassManip(theClass);
   return theClass;
   }

   static void slacLcLvn_TClassManip(TClass* theClass){
      theClass->CreateAttributeMap();
      TDictAttributeMap* attrMap( theClass->GetAttributeMap() );
      attrMap->AddProperty("file_name","sla.hh");
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *slacLcLclyd_Dictionary();
   static void slacLcLclyd_TClassManip(TClass*);
   static void delete_slacLcLclyd(void *p);
   static void deleteArray_slacLcLclyd(void *p);
   static void destruct_slacLcLclyd(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::sla::clyd*)
   {
      ::sla::clyd *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::sla::clyd));
      static ::ROOT::TGenericClassInfo 
         instance("sla::clyd", "sla.hh", 4773,
                  typeid(::sla::clyd), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &slacLcLclyd_Dictionary, isa_proxy, 4,
                  sizeof(::sla::clyd) );
      instance.SetDelete(&delete_slacLcLclyd);
      instance.SetDeleteArray(&deleteArray_slacLcLclyd);
      instance.SetDestructor(&destruct_slacLcLclyd);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::sla::clyd*)
   {
      return GenerateInitInstanceLocal((::sla::clyd*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::sla::clyd*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *slacLcLclyd_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::sla::clyd*)0x0)->GetClass();
      slacLcLclyd_TClassManip(theClass);
   return theClass;
   }

   static void slacLcLclyd_TClassManip(TClass* theClass){
      theClass->CreateAttributeMap();
      TDictAttributeMap* attrMap( theClass->GetAttributeMap() );
      attrMap->AddProperty("file_name","sla.hh");
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *slacLcLm2av_Dictionary();
   static void slacLcLm2av_TClassManip(TClass*);
   static void delete_slacLcLm2av(void *p);
   static void deleteArray_slacLcLm2av(void *p);
   static void destruct_slacLcLm2av(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::sla::m2av*)
   {
      ::sla::m2av *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::sla::m2av));
      static ::ROOT::TGenericClassInfo 
         instance("sla::m2av", "sla.hh", 4823,
                  typeid(::sla::m2av), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &slacLcLm2av_Dictionary, isa_proxy, 4,
                  sizeof(::sla::m2av) );
      instance.SetDelete(&delete_slacLcLm2av);
      instance.SetDeleteArray(&deleteArray_slacLcLm2av);
      instance.SetDestructor(&destruct_slacLcLm2av);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::sla::m2av*)
   {
      return GenerateInitInstanceLocal((::sla::m2av*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::sla::m2av*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *slacLcLm2av_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::sla::m2av*)0x0)->GetClass();
      slacLcLm2av_TClassManip(theClass);
   return theClass;
   }

   static void slacLcLm2av_TClassManip(TClass* theClass){
      theClass->CreateAttributeMap();
      TDictAttributeMap* attrMap( theClass->GetAttributeMap() );
      attrMap->AddProperty("file_name","sla.hh");
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *slacLcLdr2tf_Dictionary();
   static void slacLcLdr2tf_TClassManip(TClass*);
   static void delete_slacLcLdr2tf(void *p);
   static void deleteArray_slacLcLdr2tf(void *p);
   static void destruct_slacLcLdr2tf(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::sla::dr2tf*)
   {
      ::sla::dr2tf *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::sla::dr2tf));
      static ::ROOT::TGenericClassInfo 
         instance("sla::dr2tf", "sla.hh", 4883,
                  typeid(::sla::dr2tf), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &slacLcLdr2tf_Dictionary, isa_proxy, 4,
                  sizeof(::sla::dr2tf) );
      instance.SetDelete(&delete_slacLcLdr2tf);
      instance.SetDeleteArray(&deleteArray_slacLcLdr2tf);
      instance.SetDestructor(&destruct_slacLcLdr2tf);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::sla::dr2tf*)
   {
      return GenerateInitInstanceLocal((::sla::dr2tf*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::sla::dr2tf*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *slacLcLdr2tf_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::sla::dr2tf*)0x0)->GetClass();
      slacLcLdr2tf_TClassManip(theClass);
   return theClass;
   }

   static void slacLcLdr2tf_TClassManip(TClass* theClass){
      theClass->CreateAttributeMap();
      TDictAttributeMap* attrMap( theClass->GetAttributeMap() );
      attrMap->AddProperty("file_name","sla.hh");
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *slacLcL_atms_Dictionary();
   static void slacLcL_atms_TClassManip(TClass*);
   static void delete_slacLcL_atms(void *p);
   static void deleteArray_slacLcL_atms(void *p);
   static void destruct_slacLcL_atms(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::sla::_atms*)
   {
      ::sla::_atms *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::sla::_atms));
      static ::ROOT::TGenericClassInfo 
         instance("sla::_atms", "sla.hh", 4929,
                  typeid(::sla::_atms), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &slacLcL_atms_Dictionary, isa_proxy, 4,
                  sizeof(::sla::_atms) );
      instance.SetDelete(&delete_slacLcL_atms);
      instance.SetDeleteArray(&deleteArray_slacLcL_atms);
      instance.SetDestructor(&destruct_slacLcL_atms);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::sla::_atms*)
   {
      return GenerateInitInstanceLocal((::sla::_atms*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::sla::_atms*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *slacLcL_atms_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::sla::_atms*)0x0)->GetClass();
      slacLcL_atms_TClassManip(theClass);
   return theClass;
   }

   static void slacLcL_atms_TClassManip(TClass* theClass){
      theClass->CreateAttributeMap();
      TDictAttributeMap* attrMap( theClass->GetAttributeMap() );
      attrMap->AddProperty("file_name","sla.hh");
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *slacLcLdcmpf_Dictionary();
   static void slacLcLdcmpf_TClassManip(TClass*);
   static void delete_slacLcLdcmpf(void *p);
   static void deleteArray_slacLcLdcmpf(void *p);
   static void destruct_slacLcLdcmpf(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::sla::dcmpf*)
   {
      ::sla::dcmpf *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::sla::dcmpf));
      static ::ROOT::TGenericClassInfo 
         instance("sla::dcmpf", "sla.hh", 5049,
                  typeid(::sla::dcmpf), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &slacLcLdcmpf_Dictionary, isa_proxy, 4,
                  sizeof(::sla::dcmpf) );
      instance.SetDelete(&delete_slacLcLdcmpf);
      instance.SetDeleteArray(&deleteArray_slacLcLdcmpf);
      instance.SetDestructor(&destruct_slacLcLdcmpf);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::sla::dcmpf*)
   {
      return GenerateInitInstanceLocal((::sla::dcmpf*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::sla::dcmpf*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *slacLcLdcmpf_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::sla::dcmpf*)0x0)->GetClass();
      slacLcLdcmpf_TClassManip(theClass);
   return theClass;
   }

   static void slacLcLdcmpf_TClassManip(TClass* theClass){
      theClass->CreateAttributeMap();
      TDictAttributeMap* attrMap( theClass->GetAttributeMap() );
      attrMap->AddProperty("file_name","sla.hh");
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *slacLcLafin_Dictionary();
   static void slacLcLafin_TClassManip(TClass*);
   static void delete_slacLcLafin(void *p);
   static void deleteArray_slacLcLafin(void *p);
   static void destruct_slacLcLafin(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::sla::afin*)
   {
      ::sla::afin *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::sla::afin));
      static ::ROOT::TGenericClassInfo 
         instance("sla::afin", "sla.hh", 5182,
                  typeid(::sla::afin), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &slacLcLafin_Dictionary, isa_proxy, 4,
                  sizeof(::sla::afin) );
      instance.SetDelete(&delete_slacLcLafin);
      instance.SetDeleteArray(&deleteArray_slacLcLafin);
      instance.SetDestructor(&destruct_slacLcLafin);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::sla::afin*)
   {
      return GenerateInitInstanceLocal((::sla::afin*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::sla::afin*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *slacLcLafin_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::sla::afin*)0x0)->GetClass();
      slacLcLafin_TClassManip(theClass);
   return theClass;
   }

   static void slacLcLafin_TClassManip(TClass* theClass){
      theClass->CreateAttributeMap();
      TDictAttributeMap* attrMap( theClass->GetAttributeMap() );
      attrMap->AddProperty("file_name","sla.hh");
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *slacLcLds2tp_Dictionary();
   static void slacLcLds2tp_TClassManip(TClass*);
   static void delete_slacLcLds2tp(void *p);
   static void deleteArray_slacLcLds2tp(void *p);
   static void destruct_slacLcLds2tp(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::sla::ds2tp*)
   {
      ::sla::ds2tp *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::sla::ds2tp));
      static ::ROOT::TGenericClassInfo 
         instance("sla::ds2tp", "sla.hh", 5226,
                  typeid(::sla::ds2tp), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &slacLcLds2tp_Dictionary, isa_proxy, 4,
                  sizeof(::sla::ds2tp) );
      instance.SetDelete(&delete_slacLcLds2tp);
      instance.SetDeleteArray(&deleteArray_slacLcLds2tp);
      instance.SetDestructor(&destruct_slacLcLds2tp);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::sla::ds2tp*)
   {
      return GenerateInitInstanceLocal((::sla::ds2tp*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::sla::ds2tp*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *slacLcLds2tp_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::sla::ds2tp*)0x0)->GetClass();
      slacLcLds2tp_TClassManip(theClass);
   return theClass;
   }

   static void slacLcLds2tp_TClassManip(TClass* theClass){
      theClass->CreateAttributeMap();
      TDictAttributeMap* attrMap( theClass->GetAttributeMap() );
      attrMap->AddProperty("file_name","sla.hh");
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *slacLcLdtp2s_Dictionary();
   static void slacLcLdtp2s_TClassManip(TClass*);
   static void delete_slacLcLdtp2s(void *p);
   static void deleteArray_slacLcLdtp2s(void *p);
   static void destruct_slacLcLdtp2s(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::sla::dtp2s*)
   {
      ::sla::dtp2s *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::sla::dtp2s));
      static ::ROOT::TGenericClassInfo 
         instance("sla::dtp2s", "sla.hh", 5268,
                  typeid(::sla::dtp2s), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &slacLcLdtp2s_Dictionary, isa_proxy, 4,
                  sizeof(::sla::dtp2s) );
      instance.SetDelete(&delete_slacLcLdtp2s);
      instance.SetDeleteArray(&deleteArray_slacLcLdtp2s);
      instance.SetDestructor(&destruct_slacLcLdtp2s);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::sla::dtp2s*)
   {
      return GenerateInitInstanceLocal((::sla::dtp2s*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::sla::dtp2s*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *slacLcLdtp2s_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::sla::dtp2s*)0x0)->GetClass();
      slacLcLdtp2s_TClassManip(theClass);
   return theClass;
   }

   static void slacLcLdtp2s_TClassManip(TClass* theClass){
      theClass->CreateAttributeMap();
      TDictAttributeMap* attrMap( theClass->GetAttributeMap() );
      attrMap->AddProperty("file_name","sla.hh");
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *slacLcLfk52h_Dictionary();
   static void slacLcLfk52h_TClassManip(TClass*);
   static void delete_slacLcLfk52h(void *p);
   static void deleteArray_slacLcLfk52h(void *p);
   static void destruct_slacLcLfk52h(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::sla::fk52h*)
   {
      ::sla::fk52h *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::sla::fk52h));
      static ::ROOT::TGenericClassInfo 
         instance("sla::fk52h", "sla.hh", 5339,
                  typeid(::sla::fk52h), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &slacLcLfk52h_Dictionary, isa_proxy, 4,
                  sizeof(::sla::fk52h) );
      instance.SetDelete(&delete_slacLcLfk52h);
      instance.SetDeleteArray(&deleteArray_slacLcLfk52h);
      instance.SetDestructor(&destruct_slacLcLfk52h);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::sla::fk52h*)
   {
      return GenerateInitInstanceLocal((::sla::fk52h*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::sla::fk52h*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *slacLcLfk52h_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::sla::fk52h*)0x0)->GetClass();
      slacLcLfk52h_TClassManip(theClass);
   return theClass;
   }

   static void slacLcLfk52h_TClassManip(TClass* theClass){
      theClass->CreateAttributeMap();
      TDictAttributeMap* attrMap( theClass->GetAttributeMap() );
      attrMap->AddProperty("file_name","sla.hh");
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *slacLcLmapqk_Dictionary();
   static void slacLcLmapqk_TClassManip(TClass*);
   static void delete_slacLcLmapqk(void *p);
   static void deleteArray_slacLcLmapqk(void *p);
   static void destruct_slacLcLmapqk(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::sla::mapqk*)
   {
      ::sla::mapqk *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::sla::mapqk));
      static ::ROOT::TGenericClassInfo 
         instance("sla::mapqk", "sla.hh", 5429,
                  typeid(::sla::mapqk), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &slacLcLmapqk_Dictionary, isa_proxy, 4,
                  sizeof(::sla::mapqk) );
      instance.SetDelete(&delete_slacLcLmapqk);
      instance.SetDeleteArray(&deleteArray_slacLcLmapqk);
      instance.SetDestructor(&destruct_slacLcLmapqk);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::sla::mapqk*)
   {
      return GenerateInitInstanceLocal((::sla::mapqk*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::sla::mapqk*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *slacLcLmapqk_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::sla::mapqk*)0x0)->GetClass();
      slacLcLmapqk_TClassManip(theClass);
   return theClass;
   }

   static void slacLcLmapqk_TClassManip(TClass* theClass){
      theClass->CreateAttributeMap();
      TDictAttributeMap* attrMap( theClass->GetAttributeMap() );
      attrMap->AddProperty("file_name","sla.hh");
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *slacLcLctf2r_Dictionary();
   static void slacLcLctf2r_TClassManip(TClass*);
   static void delete_slacLcLctf2r(void *p);
   static void deleteArray_slacLcLctf2r(void *p);
   static void destruct_slacLcLctf2r(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::sla::ctf2r*)
   {
      ::sla::ctf2r *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::sla::ctf2r));
      static ::ROOT::TGenericClassInfo 
         instance("sla::ctf2r", "sla.hh", 5585,
                  typeid(::sla::ctf2r), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &slacLcLctf2r_Dictionary, isa_proxy, 4,
                  sizeof(::sla::ctf2r) );
      instance.SetDelete(&delete_slacLcLctf2r);
      instance.SetDeleteArray(&deleteArray_slacLcLctf2r);
      instance.SetDestructor(&destruct_slacLcLctf2r);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::sla::ctf2r*)
   {
      return GenerateInitInstanceLocal((::sla::ctf2r*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::sla::ctf2r*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *slacLcLctf2r_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::sla::ctf2r*)0x0)->GetClass();
      slacLcLctf2r_TClassManip(theClass);
   return theClass;
   }

   static void slacLcLctf2r_TClassManip(TClass* theClass){
      theClass->CreateAttributeMap();
      TDictAttributeMap* attrMap( theClass->GetAttributeMap() );
      attrMap->AddProperty("file_name","sla.hh");
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *slacLcLpertue_Dictionary();
   static void slacLcLpertue_TClassManip(TClass*);
   static void delete_slacLcLpertue(void *p);
   static void deleteArray_slacLcLpertue(void *p);
   static void destruct_slacLcLpertue(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::sla::pertue*)
   {
      ::sla::pertue *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::sla::pertue));
      static ::ROOT::TGenericClassInfo 
         instance("sla::pertue", "sla.hh", 5789,
                  typeid(::sla::pertue), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &slacLcLpertue_Dictionary, isa_proxy, 4,
                  sizeof(::sla::pertue) );
      instance.SetDelete(&delete_slacLcLpertue);
      instance.SetDeleteArray(&deleteArray_slacLcLpertue);
      instance.SetDestructor(&destruct_slacLcLpertue);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::sla::pertue*)
   {
      return GenerateInitInstanceLocal((::sla::pertue*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::sla::pertue*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *slacLcLpertue_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::sla::pertue*)0x0)->GetClass();
      slacLcLpertue_TClassManip(theClass);
   return theClass;
   }

   static void slacLcLpertue_TClassManip(TClass* theClass){
      theClass->CreateAttributeMap();
      TDictAttributeMap* attrMap( theClass->GetAttributeMap() );
      attrMap->AddProperty("file_name","sla.hh");
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *slacLcLatmdsp_Dictionary();
   static void slacLcLatmdsp_TClassManip(TClass*);
   static void delete_slacLcLatmdsp(void *p);
   static void deleteArray_slacLcLatmdsp(void *p);
   static void destruct_slacLcLatmdsp(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::sla::atmdsp*)
   {
      ::sla::atmdsp *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::sla::atmdsp));
      static ::ROOT::TGenericClassInfo 
         instance("sla::atmdsp", "sla.hh", 5904,
                  typeid(::sla::atmdsp), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &slacLcLatmdsp_Dictionary, isa_proxy, 4,
                  sizeof(::sla::atmdsp) );
      instance.SetDelete(&delete_slacLcLatmdsp);
      instance.SetDeleteArray(&deleteArray_slacLcLatmdsp);
      instance.SetDestructor(&destruct_slacLcLatmdsp);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::sla::atmdsp*)
   {
      return GenerateInitInstanceLocal((::sla::atmdsp*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::sla::atmdsp*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *slacLcLatmdsp_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::sla::atmdsp*)0x0)->GetClass();
      slacLcLatmdsp_TClassManip(theClass);
   return theClass;
   }

   static void slacLcLatmdsp_TClassManip(TClass* theClass){
      theClass->CreateAttributeMap();
      TDictAttributeMap* attrMap( theClass->GetAttributeMap() );
      attrMap->AddProperty("file_name","sla.hh");
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *slacLcLprebn_Dictionary();
   static void slacLcLprebn_TClassManip(TClass*);
   static void delete_slacLcLprebn(void *p);
   static void deleteArray_slacLcLprebn(void *p);
   static void destruct_slacLcLprebn(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::sla::prebn*)
   {
      ::sla::prebn *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::sla::prebn));
      static ::ROOT::TGenericClassInfo 
         instance("sla::prebn", "sla.hh", 5954,
                  typeid(::sla::prebn), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &slacLcLprebn_Dictionary, isa_proxy, 4,
                  sizeof(::sla::prebn) );
      instance.SetDelete(&delete_slacLcLprebn);
      instance.SetDeleteArray(&deleteArray_slacLcLprebn);
      instance.SetDestructor(&destruct_slacLcLprebn);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::sla::prebn*)
   {
      return GenerateInitInstanceLocal((::sla::prebn*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::sla::prebn*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *slacLcLprebn_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::sla::prebn*)0x0)->GetClass();
      slacLcLprebn_TClassManip(theClass);
   return theClass;
   }

   static void slacLcLprebn_TClassManip(TClass* theClass){
      theClass->CreateAttributeMap();
      TDictAttributeMap* attrMap( theClass->GetAttributeMap() );
      attrMap->AddProperty("file_name","sla.hh");
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *slacLcLh2e_Dictionary();
   static void slacLcLh2e_TClassManip(TClass*);
   static void delete_slacLcLh2e(void *p);
   static void deleteArray_slacLcLh2e(void *p);
   static void destruct_slacLcLh2e(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::sla::h2e*)
   {
      ::sla::h2e *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::sla::h2e));
      static ::ROOT::TGenericClassInfo 
         instance("sla::h2e", "sla.hh", 6026,
                  typeid(::sla::h2e), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &slacLcLh2e_Dictionary, isa_proxy, 4,
                  sizeof(::sla::h2e) );
      instance.SetDelete(&delete_slacLcLh2e);
      instance.SetDeleteArray(&deleteArray_slacLcLh2e);
      instance.SetDestructor(&destruct_slacLcLh2e);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::sla::h2e*)
   {
      return GenerateInitInstanceLocal((::sla::h2e*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::sla::h2e*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *slacLcLh2e_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::sla::h2e*)0x0)->GetClass();
      slacLcLh2e_TClassManip(theClass);
   return theClass;
   }

   static void slacLcLh2e_TClassManip(TClass* theClass){
      theClass->CreateAttributeMap();
      TDictAttributeMap* attrMap( theClass->GetAttributeMap() );
      attrMap->AddProperty("file_name","sla.hh");
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *slacLcLue2el_Dictionary();
   static void slacLcLue2el_TClassManip(TClass*);
   static void delete_slacLcLue2el(void *p);
   static void deleteArray_slacLcLue2el(void *p);
   static void destruct_slacLcLue2el(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::sla::ue2el*)
   {
      ::sla::ue2el *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::sla::ue2el));
      static ::ROOT::TGenericClassInfo 
         instance("sla::ue2el", "sla.hh", 6311,
                  typeid(::sla::ue2el), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &slacLcLue2el_Dictionary, isa_proxy, 4,
                  sizeof(::sla::ue2el) );
      instance.SetDelete(&delete_slacLcLue2el);
      instance.SetDeleteArray(&deleteArray_slacLcLue2el);
      instance.SetDestructor(&destruct_slacLcLue2el);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::sla::ue2el*)
   {
      return GenerateInitInstanceLocal((::sla::ue2el*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::sla::ue2el*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *slacLcLue2el_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::sla::ue2el*)0x0)->GetClass();
      slacLcLue2el_TClassManip(theClass);
   return theClass;
   }

   static void slacLcLue2el_TClassManip(TClass* theClass){
      theClass->CreateAttributeMap();
      TDictAttributeMap* attrMap( theClass->GetAttributeMap() );
      attrMap->AddProperty("file_name","sla.hh");
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *slacLcLeg50_Dictionary();
   static void slacLcLeg50_TClassManip(TClass*);
   static void delete_slacLcLeg50(void *p);
   static void deleteArray_slacLcLeg50(void *p);
   static void destruct_slacLcLeg50(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::sla::eg50*)
   {
      ::sla::eg50 *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::sla::eg50));
      static ::ROOT::TGenericClassInfo 
         instance("sla::eg50", "sla.hh", 6363,
                  typeid(::sla::eg50), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &slacLcLeg50_Dictionary, isa_proxy, 4,
                  sizeof(::sla::eg50) );
      instance.SetDelete(&delete_slacLcLeg50);
      instance.SetDeleteArray(&deleteArray_slacLcLeg50);
      instance.SetDestructor(&destruct_slacLcLeg50);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::sla::eg50*)
   {
      return GenerateInitInstanceLocal((::sla::eg50*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::sla::eg50*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *slacLcLeg50_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::sla::eg50*)0x0)->GetClass();
      slacLcLeg50_TClassManip(theClass);
   return theClass;
   }

   static void slacLcLeg50_TClassManip(TClass* theClass){
      theClass->CreateAttributeMap();
      TDictAttributeMap* attrMap( theClass->GetAttributeMap() );
      attrMap->AddProperty("file_name","sla.hh");
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *slacLcLinvf_Dictionary();
   static void slacLcLinvf_TClassManip(TClass*);
   static void delete_slacLcLinvf(void *p);
   static void deleteArray_slacLcLinvf(void *p);
   static void destruct_slacLcLinvf(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::sla::invf*)
   {
      ::sla::invf *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::sla::invf));
      static ::ROOT::TGenericClassInfo 
         instance("sla::invf", "sla.hh", 6441,
                  typeid(::sla::invf), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &slacLcLinvf_Dictionary, isa_proxy, 4,
                  sizeof(::sla::invf) );
      instance.SetDelete(&delete_slacLcLinvf);
      instance.SetDeleteArray(&deleteArray_slacLcLinvf);
      instance.SetDestructor(&destruct_slacLcLinvf);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::sla::invf*)
   {
      return GenerateInitInstanceLocal((::sla::invf*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::sla::invf*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *slacLcLinvf_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::sla::invf*)0x0)->GetClass();
      slacLcLinvf_TClassManip(theClass);
   return theClass;
   }

   static void slacLcLinvf_TClassManip(TClass* theClass){
      theClass->CreateAttributeMap();
      TDictAttributeMap* attrMap( theClass->GetAttributeMap() );
      attrMap->AddProperty("file_name","sla.hh");
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *slacLcLfk45z_Dictionary();
   static void slacLcLfk45z_TClassManip(TClass*);
   static void delete_slacLcLfk45z(void *p);
   static void deleteArray_slacLcLfk45z(void *p);
   static void destruct_slacLcLfk45z(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::sla::fk45z*)
   {
      ::sla::fk45z *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::sla::fk45z));
      static ::ROOT::TGenericClassInfo 
         instance("sla::fk45z", "sla.hh", 6538,
                  typeid(::sla::fk45z), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &slacLcLfk45z_Dictionary, isa_proxy, 4,
                  sizeof(::sla::fk45z) );
      instance.SetDelete(&delete_slacLcLfk45z);
      instance.SetDeleteArray(&deleteArray_slacLcLfk45z);
      instance.SetDestructor(&destruct_slacLcLfk45z);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::sla::fk45z*)
   {
      return GenerateInitInstanceLocal((::sla::fk45z*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::sla::fk45z*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *slacLcLfk45z_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::sla::fk45z*)0x0)->GetClass();
      slacLcLfk45z_TClassManip(theClass);
   return theClass;
   }

   static void slacLcLfk45z_TClassManip(TClass* theClass){
      theClass->CreateAttributeMap();
      TDictAttributeMap* attrMap( theClass->GetAttributeMap() );
      attrMap->AddProperty("file_name","sla.hh");
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *slacLcLdimxv_Dictionary();
   static void slacLcLdimxv_TClassManip(TClass*);
   static void delete_slacLcLdimxv(void *p);
   static void deleteArray_slacLcLdimxv(void *p);
   static void destruct_slacLcLdimxv(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::sla::dimxv*)
   {
      ::sla::dimxv *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::sla::dimxv));
      static ::ROOT::TGenericClassInfo 
         instance("sla::dimxv", "sla.hh", 6584,
                  typeid(::sla::dimxv), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &slacLcLdimxv_Dictionary, isa_proxy, 4,
                  sizeof(::sla::dimxv) );
      instance.SetDelete(&delete_slacLcLdimxv);
      instance.SetDeleteArray(&deleteArray_slacLcLdimxv);
      instance.SetDestructor(&destruct_slacLcLdimxv);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::sla::dimxv*)
   {
      return GenerateInitInstanceLocal((::sla::dimxv*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::sla::dimxv*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *slacLcLdimxv_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::sla::dimxv*)0x0)->GetClass();
      slacLcLdimxv_TClassManip(theClass);
   return theClass;
   }

   static void slacLcLdimxv_TClassManip(TClass* theClass){
      theClass->CreateAttributeMap();
      TDictAttributeMap* attrMap( theClass->GetAttributeMap() );
      attrMap->AddProperty("file_name","sla.hh");
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *slacLcLdaf2r_Dictionary();
   static void slacLcLdaf2r_TClassManip(TClass*);
   static void delete_slacLcLdaf2r(void *p);
   static void deleteArray_slacLcLdaf2r(void *p);
   static void destruct_slacLcLdaf2r(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::sla::daf2r*)
   {
      ::sla::daf2r *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::sla::daf2r));
      static ::ROOT::TGenericClassInfo 
         instance("sla::daf2r", "sla.hh", 6634,
                  typeid(::sla::daf2r), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &slacLcLdaf2r_Dictionary, isa_proxy, 4,
                  sizeof(::sla::daf2r) );
      instance.SetDelete(&delete_slacLcLdaf2r);
      instance.SetDeleteArray(&deleteArray_slacLcLdaf2r);
      instance.SetDestructor(&destruct_slacLcLdaf2r);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::sla::daf2r*)
   {
      return GenerateInitInstanceLocal((::sla::daf2r*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::sla::daf2r*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *slacLcLdaf2r_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::sla::daf2r*)0x0)->GetClass();
      slacLcLdaf2r_TClassManip(theClass);
   return theClass;
   }

   static void slacLcLdaf2r_TClassManip(TClass* theClass){
      theClass->CreateAttributeMap();
      TDictAttributeMap* attrMap( theClass->GetAttributeMap() );
      attrMap->AddProperty("file_name","sla.hh");
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *slacLcLpdq2h_Dictionary();
   static void slacLcLpdq2h_TClassManip(TClass*);
   static void delete_slacLcLpdq2h(void *p);
   static void deleteArray_slacLcLpdq2h(void *p);
   static void destruct_slacLcLpdq2h(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::sla::pdq2h*)
   {
      ::sla::pdq2h *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::sla::pdq2h));
      static ::ROOT::TGenericClassInfo 
         instance("sla::pdq2h", "sla.hh", 6681,
                  typeid(::sla::pdq2h), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &slacLcLpdq2h_Dictionary, isa_proxy, 4,
                  sizeof(::sla::pdq2h) );
      instance.SetDelete(&delete_slacLcLpdq2h);
      instance.SetDeleteArray(&deleteArray_slacLcLpdq2h);
      instance.SetDestructor(&destruct_slacLcLpdq2h);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::sla::pdq2h*)
   {
      return GenerateInitInstanceLocal((::sla::pdq2h*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::sla::pdq2h*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *slacLcLpdq2h_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::sla::pdq2h*)0x0)->GetClass();
      slacLcLpdq2h_TClassManip(theClass);
   return theClass;
   }

   static void slacLcLpdq2h_TClassManip(TClass* theClass){
      theClass->CreateAttributeMap();
      TDictAttributeMap* attrMap( theClass->GetAttributeMap() );
      attrMap->AddProperty("file_name","sla.hh");
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *slacLcLdh2e_Dictionary();
   static void slacLcLdh2e_TClassManip(TClass*);
   static void delete_slacLcLdh2e(void *p);
   static void deleteArray_slacLcLdh2e(void *p);
   static void destruct_slacLcLdh2e(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::sla::dh2e*)
   {
      ::sla::dh2e *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::sla::dh2e));
      static ::ROOT::TGenericClassInfo 
         instance("sla::dh2e", "sla.hh", 6753,
                  typeid(::sla::dh2e), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &slacLcLdh2e_Dictionary, isa_proxy, 4,
                  sizeof(::sla::dh2e) );
      instance.SetDelete(&delete_slacLcLdh2e);
      instance.SetDeleteArray(&deleteArray_slacLcLdh2e);
      instance.SetDestructor(&destruct_slacLcLdh2e);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::sla::dh2e*)
   {
      return GenerateInitInstanceLocal((::sla::dh2e*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::sla::dh2e*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *slacLcLdh2e_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::sla::dh2e*)0x0)->GetClass();
      slacLcLdh2e_TClassManip(theClass);
   return theClass;
   }

   static void slacLcLdh2e_TClassManip(TClass* theClass){
      theClass->CreateAttributeMap();
      TDictAttributeMap* attrMap( theClass->GetAttributeMap() );
      attrMap->AddProperty("file_name","sla.hh");
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *slacLcLdtps2c_Dictionary();
   static void slacLcLdtps2c_TClassManip(TClass*);
   static void delete_slacLcLdtps2c(void *p);
   static void deleteArray_slacLcLdtps2c(void *p);
   static void destruct_slacLcLdtps2c(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::sla::dtps2c*)
   {
      ::sla::dtps2c *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::sla::dtps2c));
      static ::ROOT::TGenericClassInfo 
         instance("sla::dtps2c", "sla.hh", 6824,
                  typeid(::sla::dtps2c), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &slacLcLdtps2c_Dictionary, isa_proxy, 4,
                  sizeof(::sla::dtps2c) );
      instance.SetDelete(&delete_slacLcLdtps2c);
      instance.SetDeleteArray(&deleteArray_slacLcLdtps2c);
      instance.SetDestructor(&destruct_slacLcLdtps2c);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::sla::dtps2c*)
   {
      return GenerateInitInstanceLocal((::sla::dtps2c*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::sla::dtps2c*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *slacLcLdtps2c_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::sla::dtps2c*)0x0)->GetClass();
      slacLcLdtps2c_TClassManip(theClass);
   return theClass;
   }

   static void slacLcLdtps2c_TClassManip(TClass* theClass){
      theClass->CreateAttributeMap();
      TDictAttributeMap* attrMap( theClass->GetAttributeMap() );
      attrMap->AddProperty("file_name","sla.hh");
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *slacLcLdm2av_Dictionary();
   static void slacLcLdm2av_TClassManip(TClass*);
   static void delete_slacLcLdm2av(void *p);
   static void deleteArray_slacLcLdm2av(void *p);
   static void destruct_slacLcLdm2av(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::sla::dm2av*)
   {
      ::sla::dm2av *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::sla::dm2av));
      static ::ROOT::TGenericClassInfo 
         instance("sla::dm2av", "sla.hh", 6874,
                  typeid(::sla::dm2av), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &slacLcLdm2av_Dictionary, isa_proxy, 4,
                  sizeof(::sla::dm2av) );
      instance.SetDelete(&delete_slacLcLdm2av);
      instance.SetDeleteArray(&deleteArray_slacLcLdm2av);
      instance.SetDestructor(&destruct_slacLcLdm2av);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::sla::dm2av*)
   {
      return GenerateInitInstanceLocal((::sla::dm2av*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::sla::dm2av*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *slacLcLdm2av_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::sla::dm2av*)0x0)->GetClass();
      slacLcLdm2av_TClassManip(theClass);
   return theClass;
   }

   static void slacLcLdm2av_TClassManip(TClass* theClass){
      theClass->CreateAttributeMap();
      TDictAttributeMap* attrMap( theClass->GetAttributeMap() );
      attrMap->AddProperty("file_name","sla.hh");
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *slacLcLprec_Dictionary();
   static void slacLcLprec_TClassManip(TClass*);
   static void delete_slacLcLprec(void *p);
   static void deleteArray_slacLcLprec(void *p);
   static void destruct_slacLcLprec(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::sla::prec*)
   {
      ::sla::prec *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::sla::prec));
      static ::ROOT::TGenericClassInfo 
         instance("sla::prec", "sla.hh", 6941,
                  typeid(::sla::prec), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &slacLcLprec_Dictionary, isa_proxy, 4,
                  sizeof(::sla::prec) );
      instance.SetDelete(&delete_slacLcLprec);
      instance.SetDeleteArray(&deleteArray_slacLcLprec);
      instance.SetDestructor(&destruct_slacLcLprec);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::sla::prec*)
   {
      return GenerateInitInstanceLocal((::sla::prec*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::sla::prec*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *slacLcLprec_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::sla::prec*)0x0)->GetClass();
      slacLcLprec_TClassManip(theClass);
   return theClass;
   }

   static void slacLcLprec_TClassManip(TClass* theClass){
      theClass->CreateAttributeMap();
      TDictAttributeMap* attrMap( theClass->GetAttributeMap() );
      attrMap->AddProperty("file_name","sla.hh");
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *slacLcLplante_Dictionary();
   static void slacLcLplante_TClassManip(TClass*);
   static void delete_slacLcLplante(void *p);
   static void deleteArray_slacLcLplante(void *p);
   static void destruct_slacLcLplante(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::sla::plante*)
   {
      ::sla::plante *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::sla::plante));
      static ::ROOT::TGenericClassInfo 
         instance("sla::plante", "sla.hh", 7219,
                  typeid(::sla::plante), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &slacLcLplante_Dictionary, isa_proxy, 4,
                  sizeof(::sla::plante) );
      instance.SetDelete(&delete_slacLcLplante);
      instance.SetDeleteArray(&deleteArray_slacLcLplante);
      instance.SetDestructor(&destruct_slacLcLplante);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::sla::plante*)
   {
      return GenerateInitInstanceLocal((::sla::plante*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::sla::plante*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *slacLcLplante_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::sla::plante*)0x0)->GetClass();
      slacLcLplante_TClassManip(theClass);
   return theClass;
   }

   static void slacLcLplante_TClassManip(TClass* theClass){
      theClass->CreateAttributeMap();
      TDictAttributeMap* attrMap( theClass->GetAttributeMap() );
      attrMap->AddProperty("file_name","sla.hh");
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *slacLcLprecl_Dictionary();
   static void slacLcLprecl_TClassManip(TClass*);
   static void delete_slacLcLprecl(void *p);
   static void deleteArray_slacLcLprecl(void *p);
   static void destruct_slacLcLprecl(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::sla::precl*)
   {
      ::sla::precl *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::sla::precl));
      static ::ROOT::TGenericClassInfo 
         instance("sla::precl", "sla.hh", 7305,
                  typeid(::sla::precl), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &slacLcLprecl_Dictionary, isa_proxy, 4,
                  sizeof(::sla::precl) );
      instance.SetDelete(&delete_slacLcLprecl);
      instance.SetDeleteArray(&deleteArray_slacLcLprecl);
      instance.SetDestructor(&destruct_slacLcLprecl);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::sla::precl*)
   {
      return GenerateInitInstanceLocal((::sla::precl*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::sla::precl*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *slacLcLprecl_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::sla::precl*)0x0)->GetClass();
      slacLcLprecl_TClassManip(theClass);
   return theClass;
   }

   static void slacLcLprecl_TClassManip(TClass* theClass){
      theClass->CreateAttributeMap();
      TDictAttributeMap* attrMap( theClass->GetAttributeMap() );
      attrMap->AddProperty("file_name","sla.hh");
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *slacLcLkbj_Dictionary();
   static void slacLcLkbj_TClassManip(TClass*);
   static void delete_slacLcLkbj(void *p);
   static void deleteArray_slacLcLkbj(void *p);
   static void destruct_slacLcLkbj(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::sla::kbj*)
   {
      ::sla::kbj *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::sla::kbj));
      static ::ROOT::TGenericClassInfo 
         instance("sla::kbj", "sla.hh", 7347,
                  typeid(::sla::kbj), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &slacLcLkbj_Dictionary, isa_proxy, 4,
                  sizeof(::sla::kbj) );
      instance.SetDelete(&delete_slacLcLkbj);
      instance.SetDeleteArray(&deleteArray_slacLcLkbj);
      instance.SetDestructor(&destruct_slacLcLkbj);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::sla::kbj*)
   {
      return GenerateInitInstanceLocal((::sla::kbj*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::sla::kbj*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *slacLcLkbj_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::sla::kbj*)0x0)->GetClass();
      slacLcLkbj_TClassManip(theClass);
   return theClass;
   }

   static void slacLcLkbj_TClassManip(TClass* theClass){
      theClass->CreateAttributeMap();
      TDictAttributeMap* attrMap( theClass->GetAttributeMap() );
      attrMap->AddProperty("file_name","sla.hh");
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *slacLcLpv2ue_Dictionary();
   static void slacLcLpv2ue_TClassManip(TClass*);
   static void delete_slacLcLpv2ue(void *p);
   static void deleteArray_slacLcLpv2ue(void *p);
   static void destruct_slacLcLpv2ue(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::sla::pv2ue*)
   {
      ::sla::pv2ue *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::sla::pv2ue));
      static ::ROOT::TGenericClassInfo 
         instance("sla::pv2ue", "sla.hh", 7431,
                  typeid(::sla::pv2ue), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &slacLcLpv2ue_Dictionary, isa_proxy, 4,
                  sizeof(::sla::pv2ue) );
      instance.SetDelete(&delete_slacLcLpv2ue);
      instance.SetDeleteArray(&deleteArray_slacLcLpv2ue);
      instance.SetDestructor(&destruct_slacLcLpv2ue);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::sla::pv2ue*)
   {
      return GenerateInitInstanceLocal((::sla::pv2ue*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::sla::pv2ue*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *slacLcLpv2ue_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::sla::pv2ue*)0x0)->GetClass();
      slacLcLpv2ue_TClassManip(theClass);
   return theClass;
   }

   static void slacLcLpv2ue_TClassManip(TClass* theClass){
      theClass->CreateAttributeMap();
      TDictAttributeMap* attrMap( theClass->GetAttributeMap() );
      attrMap->AddProperty("file_name","sla.hh");
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *slacLcLdcs2c_Dictionary();
   static void slacLcLdcs2c_TClassManip(TClass*);
   static void delete_slacLcLdcs2c(void *p);
   static void deleteArray_slacLcLdcs2c(void *p);
   static void destruct_slacLcLdcs2c(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::sla::dcs2c*)
   {
      ::sla::dcs2c *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::sla::dcs2c));
      static ::ROOT::TGenericClassInfo 
         instance("sla::dcs2c", "sla.hh", 7475,
                  typeid(::sla::dcs2c), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &slacLcLdcs2c_Dictionary, isa_proxy, 4,
                  sizeof(::sla::dcs2c) );
      instance.SetDelete(&delete_slacLcLdcs2c);
      instance.SetDeleteArray(&deleteArray_slacLcLdcs2c);
      instance.SetDestructor(&destruct_slacLcLdcs2c);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::sla::dcs2c*)
   {
      return GenerateInitInstanceLocal((::sla::dcs2c*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::sla::dcs2c*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *slacLcLdcs2c_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::sla::dcs2c*)0x0)->GetClass();
      slacLcLdcs2c_TClassManip(theClass);
   return theClass;
   }

   static void slacLcLdcs2c_TClassManip(TClass* theClass){
      theClass->CreateAttributeMap();
      TDictAttributeMap* attrMap( theClass->GetAttributeMap() );
      attrMap->AddProperty("file_name","sla.hh");
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *slacLcLfk54z_Dictionary();
   static void slacLcLfk54z_TClassManip(TClass*);
   static void delete_slacLcLfk54z(void *p);
   static void deleteArray_slacLcLfk54z(void *p);
   static void destruct_slacLcLfk54z(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::sla::fk54z*)
   {
      ::sla::fk54z *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::sla::fk54z));
      static ::ROOT::TGenericClassInfo 
         instance("sla::fk54z", "sla.hh", 7544,
                  typeid(::sla::fk54z), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &slacLcLfk54z_Dictionary, isa_proxy, 4,
                  sizeof(::sla::fk54z) );
      instance.SetDelete(&delete_slacLcLfk54z);
      instance.SetDeleteArray(&deleteArray_slacLcLfk54z);
      instance.SetDestructor(&destruct_slacLcLfk54z);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::sla::fk54z*)
   {
      return GenerateInitInstanceLocal((::sla::fk54z*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::sla::fk54z*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *slacLcLfk54z_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::sla::fk54z*)0x0)->GetClass();
      slacLcLfk54z_TClassManip(theClass);
   return theClass;
   }

   static void slacLcLfk54z_TClassManip(TClass* theClass){
      theClass->CreateAttributeMap();
      TDictAttributeMap* attrMap( theClass->GetAttributeMap() );
      attrMap->AddProperty("file_name","sla.hh");
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *slacLcL_idchf_Dictionary();
   static void slacLcL_idchf_TClassManip(TClass*);
   static void delete_slacLcL_idchf(void *p);
   static void deleteArray_slacLcL_idchf(void *p);
   static void destruct_slacLcL_idchf(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::sla::_idchf*)
   {
      ::sla::_idchf *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::sla::_idchf));
      static ::ROOT::TGenericClassInfo 
         instance("sla::_idchf", "sla.hh", 7603,
                  typeid(::sla::_idchf), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &slacLcL_idchf_Dictionary, isa_proxy, 4,
                  sizeof(::sla::_idchf) );
      instance.SetDelete(&delete_slacLcL_idchf);
      instance.SetDeleteArray(&deleteArray_slacLcL_idchf);
      instance.SetDestructor(&destruct_slacLcL_idchf);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::sla::_idchf*)
   {
      return GenerateInitInstanceLocal((::sla::_idchf*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::sla::_idchf*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *slacLcL_idchf_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::sla::_idchf*)0x0)->GetClass();
      slacLcL_idchf_TClassManip(theClass);
   return theClass;
   }

   static void slacLcL_idchf_TClassManip(TClass* theClass){
      theClass->CreateAttributeMap();
      TDictAttributeMap* attrMap( theClass->GetAttributeMap() );
      attrMap->AddProperty("file_name","sla.hh");
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *slacLcLdjcl_Dictionary();
   static void slacLcLdjcl_TClassManip(TClass*);
   static void delete_slacLcLdjcl(void *p);
   static void deleteArray_slacLcLdjcl(void *p);
   static void destruct_slacLcLdjcl(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::sla::djcl*)
   {
      ::sla::djcl *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::sla::djcl));
      static ::ROOT::TGenericClassInfo 
         instance("sla::djcl", "sla.hh", 7650,
                  typeid(::sla::djcl), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &slacLcLdjcl_Dictionary, isa_proxy, 4,
                  sizeof(::sla::djcl) );
      instance.SetDelete(&delete_slacLcLdjcl);
      instance.SetDeleteArray(&deleteArray_slacLcLdjcl);
      instance.SetDestructor(&destruct_slacLcLdjcl);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::sla::djcl*)
   {
      return GenerateInitInstanceLocal((::sla::djcl*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::sla::djcl*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *slacLcLdjcl_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::sla::djcl*)0x0)->GetClass();
      slacLcLdjcl_TClassManip(theClass);
   return theClass;
   }

   static void slacLcLdjcl_TClassManip(TClass* theClass){
      theClass->CreateAttributeMap();
      TDictAttributeMap* attrMap( theClass->GetAttributeMap() );
      attrMap->AddProperty("file_name","sla.hh");
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *slacLcLdc62s_Dictionary();
   static void slacLcLdc62s_TClassManip(TClass*);
   static void delete_slacLcLdc62s(void *p);
   static void deleteArray_slacLcLdc62s(void *p);
   static void destruct_slacLcLdc62s(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::sla::dc62s*)
   {
      ::sla::dc62s *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::sla::dc62s));
      static ::ROOT::TGenericClassInfo 
         instance("sla::dc62s", "sla.hh", 7725,
                  typeid(::sla::dc62s), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &slacLcLdc62s_Dictionary, isa_proxy, 4,
                  sizeof(::sla::dc62s) );
      instance.SetDelete(&delete_slacLcLdc62s);
      instance.SetDeleteArray(&deleteArray_slacLcLdc62s);
      instance.SetDestructor(&destruct_slacLcLdc62s);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::sla::dc62s*)
   {
      return GenerateInitInstanceLocal((::sla::dc62s*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::sla::dc62s*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *slacLcLdc62s_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::sla::dc62s*)0x0)->GetClass();
      slacLcLdc62s_TClassManip(theClass);
   return theClass;
   }

   static void slacLcLdc62s_TClassManip(TClass* theClass){
      theClass->CreateAttributeMap();
      TDictAttributeMap* attrMap( theClass->GetAttributeMap() );
      attrMap->AddProperty("file_name","sla.hh");
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *slacLcLeqgal_Dictionary();
   static void slacLcLeqgal_TClassManip(TClass*);
   static void delete_slacLcLeqgal(void *p);
   static void deleteArray_slacLcLeqgal(void *p);
   static void destruct_slacLcLeqgal(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::sla::eqgal*)
   {
      ::sla::eqgal *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::sla::eqgal));
      static ::ROOT::TGenericClassInfo 
         instance("sla::eqgal", "sla.hh", 7777,
                  typeid(::sla::eqgal), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &slacLcLeqgal_Dictionary, isa_proxy, 4,
                  sizeof(::sla::eqgal) );
      instance.SetDelete(&delete_slacLcLeqgal);
      instance.SetDeleteArray(&deleteArray_slacLcLeqgal);
      instance.SetDestructor(&destruct_slacLcLeqgal);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::sla::eqgal*)
   {
      return GenerateInitInstanceLocal((::sla::eqgal*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::sla::eqgal*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *slacLcLeqgal_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::sla::eqgal*)0x0)->GetClass();
      slacLcLeqgal_TClassManip(theClass);
   return theClass;
   }

   static void slacLcLeqgal_TClassManip(TClass* theClass){
      theClass->CreateAttributeMap();
      TDictAttributeMap* attrMap( theClass->GetAttributeMap() );
      attrMap->AddProperty("file_name","sla.hh");
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *slacLcLge50_Dictionary();
   static void slacLcLge50_TClassManip(TClass*);
   static void delete_slacLcLge50(void *p);
   static void deleteArray_slacLcLge50(void *p);
   static void destruct_slacLcLge50(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::sla::ge50*)
   {
      ::sla::ge50 *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::sla::ge50));
      static ::ROOT::TGenericClassInfo 
         instance("sla::ge50", "sla.hh", 7829,
                  typeid(::sla::ge50), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &slacLcLge50_Dictionary, isa_proxy, 4,
                  sizeof(::sla::ge50) );
      instance.SetDelete(&delete_slacLcLge50);
      instance.SetDeleteArray(&deleteArray_slacLcLge50);
      instance.SetDestructor(&destruct_slacLcLge50);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::sla::ge50*)
   {
      return GenerateInitInstanceLocal((::sla::ge50*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::sla::ge50*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *slacLcLge50_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::sla::ge50*)0x0)->GetClass();
      slacLcLge50_TClassManip(theClass);
   return theClass;
   }

   static void slacLcLge50_TClassManip(TClass* theClass){
      theClass->CreateAttributeMap();
      TDictAttributeMap* attrMap( theClass->GetAttributeMap() );
      attrMap->AddProperty("file_name","sla.hh");
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *slacLcLcs2c6_Dictionary();
   static void slacLcLcs2c6_TClassManip(TClass*);
   static void delete_slacLcLcs2c6(void *p);
   static void deleteArray_slacLcLcs2c6(void *p);
   static void destruct_slacLcLcs2c6(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::sla::cs2c6*)
   {
      ::sla::cs2c6 *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::sla::cs2c6));
      static ::ROOT::TGenericClassInfo 
         instance("sla::cs2c6", "sla.hh", 7945,
                  typeid(::sla::cs2c6), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &slacLcLcs2c6_Dictionary, isa_proxy, 4,
                  sizeof(::sla::cs2c6) );
      instance.SetDelete(&delete_slacLcLcs2c6);
      instance.SetDeleteArray(&deleteArray_slacLcLcs2c6);
      instance.SetDestructor(&destruct_slacLcLcs2c6);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::sla::cs2c6*)
   {
      return GenerateInitInstanceLocal((::sla::cs2c6*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::sla::cs2c6*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *slacLcLcs2c6_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::sla::cs2c6*)0x0)->GetClass();
      slacLcLcs2c6_TClassManip(theClass);
   return theClass;
   }

   static void slacLcLcs2c6_TClassManip(TClass* theClass){
      theClass->CreateAttributeMap();
      TDictAttributeMap* attrMap( theClass->GetAttributeMap() );
      attrMap->AddProperty("file_name","sla.hh");
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *slacLcLs2tp_Dictionary();
   static void slacLcLs2tp_TClassManip(TClass*);
   static void delete_slacLcLs2tp(void *p);
   static void deleteArray_slacLcLs2tp(void *p);
   static void destruct_slacLcLs2tp(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::sla::s2tp*)
   {
      ::sla::s2tp *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::sla::s2tp));
      static ::ROOT::TGenericClassInfo 
         instance("sla::s2tp", "sla.hh", 7990,
                  typeid(::sla::s2tp), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &slacLcLs2tp_Dictionary, isa_proxy, 4,
                  sizeof(::sla::s2tp) );
      instance.SetDelete(&delete_slacLcLs2tp);
      instance.SetDeleteArray(&deleteArray_slacLcLs2tp);
      instance.SetDestructor(&destruct_slacLcLs2tp);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::sla::s2tp*)
   {
      return GenerateInitInstanceLocal((::sla::s2tp*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::sla::s2tp*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *slacLcLs2tp_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::sla::s2tp*)0x0)->GetClass();
      slacLcLs2tp_TClassManip(theClass);
   return theClass;
   }

   static void slacLcLs2tp_TClassManip(TClass* theClass){
      theClass->CreateAttributeMap();
      TDictAttributeMap* attrMap( theClass->GetAttributeMap() );
      attrMap->AddProperty("file_name","sla.hh");
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *slacLcLcc2s_Dictionary();
   static void slacLcLcc2s_TClassManip(TClass*);
   static void delete_slacLcLcc2s(void *p);
   static void deleteArray_slacLcLcc2s(void *p);
   static void destruct_slacLcLcc2s(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::sla::cc2s*)
   {
      ::sla::cc2s *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::sla::cc2s));
      static ::ROOT::TGenericClassInfo 
         instance("sla::cc2s", "sla.hh", 8036,
                  typeid(::sla::cc2s), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &slacLcLcc2s_Dictionary, isa_proxy, 4,
                  sizeof(::sla::cc2s) );
      instance.SetDelete(&delete_slacLcLcc2s);
      instance.SetDeleteArray(&deleteArray_slacLcLcc2s);
      instance.SetDestructor(&destruct_slacLcLcc2s);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::sla::cc2s*)
   {
      return GenerateInitInstanceLocal((::sla::cc2s*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::sla::cc2s*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *slacLcLcc2s_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::sla::cc2s*)0x0)->GetClass();
      slacLcLcc2s_TClassManip(theClass);
   return theClass;
   }

   static void slacLcLcc2s_TClassManip(TClass* theClass){
      theClass->CreateAttributeMap();
      TDictAttributeMap* attrMap( theClass->GetAttributeMap() );
      attrMap->AddProperty("file_name","sla.hh");
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *slacLcLnut_Dictionary();
   static void slacLcLnut_TClassManip(TClass*);
   static void delete_slacLcLnut(void *p);
   static void deleteArray_slacLcLnut(void *p);
   static void destruct_slacLcLnut(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::sla::nut*)
   {
      ::sla::nut *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::sla::nut));
      static ::ROOT::TGenericClassInfo 
         instance("sla::nut", "sla.hh", 8120,
                  typeid(::sla::nut), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &slacLcLnut_Dictionary, isa_proxy, 4,
                  sizeof(::sla::nut) );
      instance.SetDelete(&delete_slacLcLnut);
      instance.SetDeleteArray(&deleteArray_slacLcLnut);
      instance.SetDestructor(&destruct_slacLcLnut);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::sla::nut*)
   {
      return GenerateInitInstanceLocal((::sla::nut*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::sla::nut*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *slacLcLnut_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::sla::nut*)0x0)->GetClass();
      slacLcLnut_TClassManip(theClass);
   return theClass;
   }

   static void slacLcLnut_TClassManip(TClass* theClass){
      theClass->CreateAttributeMap();
      TDictAttributeMap* attrMap( theClass->GetAttributeMap() );
      attrMap->AddProperty("file_name","sla.hh");
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *slacLcLv2tp_Dictionary();
   static void slacLcLv2tp_TClassManip(TClass*);
   static void delete_slacLcLv2tp(void *p);
   static void deleteArray_slacLcLv2tp(void *p);
   static void destruct_slacLcLv2tp(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::sla::v2tp*)
   {
      ::sla::v2tp *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::sla::v2tp));
      static ::ROOT::TGenericClassInfo 
         instance("sla::v2tp", "sla.hh", 8176,
                  typeid(::sla::v2tp), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &slacLcLv2tp_Dictionary, isa_proxy, 4,
                  sizeof(::sla::v2tp) );
      instance.SetDelete(&delete_slacLcLv2tp);
      instance.SetDeleteArray(&deleteArray_slacLcLv2tp);
      instance.SetDestructor(&destruct_slacLcLv2tp);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::sla::v2tp*)
   {
      return GenerateInitInstanceLocal((::sla::v2tp*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::sla::v2tp*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *slacLcLv2tp_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::sla::v2tp*)0x0)->GetClass();
      slacLcLv2tp_TClassManip(theClass);
   return theClass;
   }

   static void slacLcLv2tp_TClassManip(TClass* theClass){
      theClass->CreateAttributeMap();
      TDictAttributeMap* attrMap( theClass->GetAttributeMap() );
      attrMap->AddProperty("file_name","sla.hh");
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *slacLcLdjcal_Dictionary();
   static void slacLcLdjcal_TClassManip(TClass*);
   static void delete_slacLcLdjcal(void *p);
   static void deleteArray_slacLcLdjcal(void *p);
   static void destruct_slacLcLdjcal(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::sla::djcal*)
   {
      ::sla::djcal *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::sla::djcal));
      static ::ROOT::TGenericClassInfo 
         instance("sla::djcal", "sla.hh", 8227,
                  typeid(::sla::djcal), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &slacLcLdjcal_Dictionary, isa_proxy, 4,
                  sizeof(::sla::djcal) );
      instance.SetDelete(&delete_slacLcLdjcal);
      instance.SetDeleteArray(&deleteArray_slacLcLdjcal);
      instance.SetDestructor(&destruct_slacLcLdjcal);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::sla::djcal*)
   {
      return GenerateInitInstanceLocal((::sla::djcal*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::sla::djcal*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *slacLcLdjcal_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::sla::djcal*)0x0)->GetClass();
      slacLcLdjcal_TClassManip(theClass);
   return theClass;
   }

   static void slacLcLdjcal_TClassManip(TClass* theClass){
      theClass->CreateAttributeMap();
      TDictAttributeMap* attrMap( theClass->GetAttributeMap() );
      attrMap->AddProperty("file_name","sla.hh");
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *slacLcLdtpv2c_Dictionary();
   static void slacLcLdtpv2c_TClassManip(TClass*);
   static void delete_slacLcLdtpv2c(void *p);
   static void deleteArray_slacLcLdtpv2c(void *p);
   static void destruct_slacLcLdtpv2c(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::sla::dtpv2c*)
   {
      ::sla::dtpv2c *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::sla::dtpv2c));
      static ::ROOT::TGenericClassInfo 
         instance("sla::dtpv2c", "sla.hh", 8292,
                  typeid(::sla::dtpv2c), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &slacLcLdtpv2c_Dictionary, isa_proxy, 4,
                  sizeof(::sla::dtpv2c) );
      instance.SetDelete(&delete_slacLcLdtpv2c);
      instance.SetDeleteArray(&deleteArray_slacLcLdtpv2c);
      instance.SetDestructor(&destruct_slacLcLdtpv2c);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::sla::dtpv2c*)
   {
      return GenerateInitInstanceLocal((::sla::dtpv2c*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::sla::dtpv2c*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *slacLcLdtpv2c_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::sla::dtpv2c*)0x0)->GetClass();
      slacLcLdtpv2c_TClassManip(theClass);
   return theClass;
   }

   static void slacLcLdtpv2c_TClassManip(TClass* theClass){
      theClass->CreateAttributeMap();
      TDictAttributeMap* attrMap( theClass->GetAttributeMap() );
      attrMap->AddProperty("file_name","sla.hh");
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *slacLcL_idchi_Dictionary();
   static void slacLcL_idchi_TClassManip(TClass*);
   static void delete_slacLcL_idchi(void *p);
   static void deleteArray_slacLcL_idchi(void *p);
   static void destruct_slacLcL_idchi(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::sla::_idchi*)
   {
      ::sla::_idchi *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::sla::_idchi));
      static ::ROOT::TGenericClassInfo 
         instance("sla::_idchi", "sla.hh", 8348,
                  typeid(::sla::_idchi), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &slacLcL_idchi_Dictionary, isa_proxy, 4,
                  sizeof(::sla::_idchi) );
      instance.SetDelete(&delete_slacLcL_idchi);
      instance.SetDeleteArray(&deleteArray_slacLcL_idchi);
      instance.SetDestructor(&destruct_slacLcL_idchi);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::sla::_idchi*)
   {
      return GenerateInitInstanceLocal((::sla::_idchi*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::sla::_idchi*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *slacLcL_idchi_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::sla::_idchi*)0x0)->GetClass();
      slacLcL_idchi_TClassManip(theClass);
   return theClass;
   }

   static void slacLcL_idchi_TClassManip(TClass* theClass){
      theClass->CreateAttributeMap();
      TDictAttributeMap* attrMap( theClass->GetAttributeMap() );
      attrMap->AddProperty("file_name","sla.hh");
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *slacLcLds2c6_Dictionary();
   static void slacLcLds2c6_TClassManip(TClass*);
   static void delete_slacLcLds2c6(void *p);
   static void deleteArray_slacLcLds2c6(void *p);
   static void destruct_slacLcLds2c6(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::sla::ds2c6*)
   {
      ::sla::ds2c6 *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::sla::ds2c6));
      static ::ROOT::TGenericClassInfo 
         instance("sla::ds2c6", "sla.hh", 8433,
                  typeid(::sla::ds2c6), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &slacLcLds2c6_Dictionary, isa_proxy, 4,
                  sizeof(::sla::ds2c6) );
      instance.SetDelete(&delete_slacLcLds2c6);
      instance.SetDeleteArray(&deleteArray_slacLcLds2c6);
      instance.SetDestructor(&destruct_slacLcLds2c6);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::sla::ds2c6*)
   {
      return GenerateInitInstanceLocal((::sla::ds2c6*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::sla::ds2c6*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *slacLcLds2c6_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::sla::ds2c6*)0x0)->GetClass();
      slacLcLds2c6_TClassManip(theClass);
   return theClass;
   }

   static void slacLcLds2c6_TClassManip(TClass* theClass){
      theClass->CreateAttributeMap();
      TDictAttributeMap* attrMap( theClass->GetAttributeMap() );
      attrMap->AddProperty("file_name","sla.hh");
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *slacLcLetrms_Dictionary();
   static void slacLcLetrms_TClassManip(TClass*);
   static void delete_slacLcLetrms(void *p);
   static void deleteArray_slacLcLetrms(void *p);
   static void destruct_slacLcLetrms(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::sla::etrms*)
   {
      ::sla::etrms *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::sla::etrms));
      static ::ROOT::TGenericClassInfo 
         instance("sla::etrms", "sla.hh", 8482,
                  typeid(::sla::etrms), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &slacLcLetrms_Dictionary, isa_proxy, 4,
                  sizeof(::sla::etrms) );
      instance.SetDelete(&delete_slacLcLetrms);
      instance.SetDeleteArray(&deleteArray_slacLcLetrms);
      instance.SetDestructor(&destruct_slacLcLetrms);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::sla::etrms*)
   {
      return GenerateInitInstanceLocal((::sla::etrms*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::sla::etrms*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *slacLcLetrms_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::sla::etrms*)0x0)->GetClass();
      slacLcLetrms_TClassManip(theClass);
   return theClass;
   }

   static void slacLcLetrms_TClassManip(TClass* theClass){
      theClass->CreateAttributeMap();
      TDictAttributeMap* attrMap( theClass->GetAttributeMap() );
      attrMap->AddProperty("file_name","sla.hh");
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *slacLcLrefcoq_Dictionary();
   static void slacLcLrefcoq_TClassManip(TClass*);
   static void delete_slacLcLrefcoq(void *p);
   static void deleteArray_slacLcLrefcoq(void *p);
   static void destruct_slacLcLrefcoq(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::sla::refcoq*)
   {
      ::sla::refcoq *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::sla::refcoq));
      static ::ROOT::TGenericClassInfo 
         instance("sla::refcoq", "sla.hh", 8664,
                  typeid(::sla::refcoq), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &slacLcLrefcoq_Dictionary, isa_proxy, 4,
                  sizeof(::sla::refcoq) );
      instance.SetDelete(&delete_slacLcLrefcoq);
      instance.SetDeleteArray(&deleteArray_slacLcLrefcoq);
      instance.SetDestructor(&destruct_slacLcLrefcoq);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::sla::refcoq*)
   {
      return GenerateInitInstanceLocal((::sla::refcoq*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::sla::refcoq*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *slacLcLrefcoq_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::sla::refcoq*)0x0)->GetClass();
      slacLcLrefcoq_TClassManip(theClass);
   return theClass;
   }

   static void slacLcLrefcoq_TClassManip(TClass* theClass){
      theClass->CreateAttributeMap();
      TDictAttributeMap* attrMap( theClass->GetAttributeMap() );
      attrMap->AddProperty("file_name","sla.hh");
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *slacLcLeqecl_Dictionary();
   static void slacLcLeqecl_TClassManip(TClass*);
   static void delete_slacLcLeqecl(void *p);
   static void deleteArray_slacLcLeqecl(void *p);
   static void destruct_slacLcLeqecl(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::sla::eqecl*)
   {
      ::sla::eqecl *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::sla::eqecl));
      static ::ROOT::TGenericClassInfo 
         instance("sla::eqecl", "sla.hh", 8709,
                  typeid(::sla::eqecl), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &slacLcLeqecl_Dictionary, isa_proxy, 4,
                  sizeof(::sla::eqecl) );
      instance.SetDelete(&delete_slacLcLeqecl);
      instance.SetDeleteArray(&deleteArray_slacLcLeqecl);
      instance.SetDestructor(&destruct_slacLcLeqecl);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::sla::eqecl*)
   {
      return GenerateInitInstanceLocal((::sla::eqecl*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::sla::eqecl*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *slacLcLeqecl_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::sla::eqecl*)0x0)->GetClass();
      slacLcLeqecl_TClassManip(theClass);
   return theClass;
   }

   static void slacLcLeqecl_TClassManip(TClass* theClass){
      theClass->CreateAttributeMap();
      TDictAttributeMap* attrMap( theClass->GetAttributeMap() );
      attrMap->AddProperty("file_name","sla.hh");
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *slacLcLtps2c_Dictionary();
   static void slacLcLtps2c_TClassManip(TClass*);
   static void delete_slacLcLtps2c(void *p);
   static void deleteArray_slacLcLtps2c(void *p);
   static void destruct_slacLcLtps2c(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::sla::tps2c*)
   {
      ::sla::tps2c *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::sla::tps2c));
      static ::ROOT::TGenericClassInfo 
         instance("sla::tps2c", "sla.hh", 8835,
                  typeid(::sla::tps2c), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &slacLcLtps2c_Dictionary, isa_proxy, 4,
                  sizeof(::sla::tps2c) );
      instance.SetDelete(&delete_slacLcLtps2c);
      instance.SetDeleteArray(&deleteArray_slacLcLtps2c);
      instance.SetDestructor(&destruct_slacLcLtps2c);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::sla::tps2c*)
   {
      return GenerateInitInstanceLocal((::sla::tps2c*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::sla::tps2c*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *slacLcLtps2c_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::sla::tps2c*)0x0)->GetClass();
      slacLcLtps2c_TClassManip(theClass);
   return theClass;
   }

   static void slacLcLtps2c_TClassManip(TClass* theClass){
      theClass->CreateAttributeMap();
      TDictAttributeMap* attrMap( theClass->GetAttributeMap() );
      attrMap->AddProperty("file_name","sla.hh");
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *slacLcLfk425_Dictionary();
   static void slacLcLfk425_TClassManip(TClass*);
   static void delete_slacLcLfk425(void *p);
   static void deleteArray_slacLcLfk425(void *p);
   static void destruct_slacLcLfk425(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::sla::fk425*)
   {
      ::sla::fk425 *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::sla::fk425));
      static ::ROOT::TGenericClassInfo 
         instance("sla::fk425", "sla.hh", 8929,
                  typeid(::sla::fk425), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &slacLcLfk425_Dictionary, isa_proxy, 4,
                  sizeof(::sla::fk425) );
      instance.SetDelete(&delete_slacLcLfk425);
      instance.SetDeleteArray(&deleteArray_slacLcLfk425);
      instance.SetDestructor(&destruct_slacLcLfk425);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::sla::fk425*)
   {
      return GenerateInitInstanceLocal((::sla::fk425*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::sla::fk425*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *slacLcLfk425_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::sla::fk425*)0x0)->GetClass();
      slacLcLfk425_TClassManip(theClass);
   return theClass;
   }

   static void slacLcLfk425_TClassManip(TClass* theClass){
      theClass->CreateAttributeMap();
      TDictAttributeMap* attrMap( theClass->GetAttributeMap() );
      attrMap->AddProperty("file_name","sla.hh");
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *slacLcLdv2tp_Dictionary();
   static void slacLcLdv2tp_TClassManip(TClass*);
   static void delete_slacLcLdv2tp(void *p);
   static void deleteArray_slacLcLdv2tp(void *p);
   static void destruct_slacLcLdv2tp(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::sla::dv2tp*)
   {
      ::sla::dv2tp *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::sla::dv2tp));
      static ::ROOT::TGenericClassInfo 
         instance("sla::dv2tp", "sla.hh", 8985,
                  typeid(::sla::dv2tp), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &slacLcLdv2tp_Dictionary, isa_proxy, 4,
                  sizeof(::sla::dv2tp) );
      instance.SetDelete(&delete_slacLcLdv2tp);
      instance.SetDeleteArray(&deleteArray_slacLcLdv2tp);
      instance.SetDestructor(&destruct_slacLcLdv2tp);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::sla::dv2tp*)
   {
      return GenerateInitInstanceLocal((::sla::dv2tp*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::sla::dv2tp*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *slacLcLdv2tp_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::sla::dv2tp*)0x0)->GetClass();
      slacLcLdv2tp_TClassManip(theClass);
   return theClass;
   }

   static void slacLcLdv2tp_TClassManip(TClass* theClass){
      theClass->CreateAttributeMap();
      TDictAttributeMap* attrMap( theClass->GetAttributeMap() );
      attrMap->AddProperty("file_name","sla.hh");
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *slacLcLtp2s_Dictionary();
   static void slacLcLtp2s_TClassManip(TClass*);
   static void delete_slacLcLtp2s(void *p);
   static void deleteArray_slacLcLtp2s(void *p);
   static void destruct_slacLcLtp2s(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::sla::tp2s*)
   {
      ::sla::tp2s *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::sla::tp2s));
      static ::ROOT::TGenericClassInfo 
         instance("sla::tp2s", "sla.hh", 9027,
                  typeid(::sla::tp2s), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &slacLcLtp2s_Dictionary, isa_proxy, 4,
                  sizeof(::sla::tp2s) );
      instance.SetDelete(&delete_slacLcLtp2s);
      instance.SetDeleteArray(&deleteArray_slacLcLtp2s);
      instance.SetDestructor(&destruct_slacLcLtp2s);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::sla::tp2s*)
   {
      return GenerateInitInstanceLocal((::sla::tp2s*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::sla::tp2s*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *slacLcLtp2s_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::sla::tp2s*)0x0)->GetClass();
      slacLcLtp2s_TClassManip(theClass);
   return theClass;
   }

   static void slacLcLtp2s_TClassManip(TClass* theClass){
      theClass->CreateAttributeMap();
      TDictAttributeMap* attrMap( theClass->GetAttributeMap() );
      attrMap->AddProperty("file_name","sla.hh");
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *slacLcLdmoon_Dictionary();
   static void slacLcLdmoon_TClassManip(TClass*);
   static void delete_slacLcLdmoon(void *p);
   static void deleteArray_slacLcLdmoon(void *p);
   static void destruct_slacLcLdmoon(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::sla::dmoon*)
   {
      ::sla::dmoon *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::sla::dmoon));
      static ::ROOT::TGenericClassInfo 
         instance("sla::dmoon", "sla.hh", 9099,
                  typeid(::sla::dmoon), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &slacLcLdmoon_Dictionary, isa_proxy, 4,
                  sizeof(::sla::dmoon) );
      instance.SetDelete(&delete_slacLcLdmoon);
      instance.SetDeleteArray(&deleteArray_slacLcLdmoon);
      instance.SetDestructor(&destruct_slacLcLdmoon);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::sla::dmoon*)
   {
      return GenerateInitInstanceLocal((::sla::dmoon*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::sla::dmoon*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *slacLcLdmoon_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::sla::dmoon*)0x0)->GetClass();
      slacLcLdmoon_TClassManip(theClass);
   return theClass;
   }

   static void slacLcLdmoon_TClassManip(TClass* theClass){
      theClass->CreateAttributeMap();
      TDictAttributeMap* attrMap( theClass->GetAttributeMap() );
      attrMap->AddProperty("file_name","sla.hh");
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *slacLcLcaf2r_Dictionary();
   static void slacLcLcaf2r_TClassManip(TClass*);
   static void delete_slacLcLcaf2r(void *p);
   static void deleteArray_slacLcLcaf2r(void *p);
   static void destruct_slacLcLcaf2r(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::sla::caf2r*)
   {
      ::sla::caf2r *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::sla::caf2r));
      static ::ROOT::TGenericClassInfo 
         instance("sla::caf2r", "sla.hh", 9151,
                  typeid(::sla::caf2r), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &slacLcLcaf2r_Dictionary, isa_proxy, 4,
                  sizeof(::sla::caf2r) );
      instance.SetDelete(&delete_slacLcLcaf2r);
      instance.SetDeleteArray(&deleteArray_slacLcLcaf2r);
      instance.SetDestructor(&destruct_slacLcLcaf2r);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::sla::caf2r*)
   {
      return GenerateInitInstanceLocal((::sla::caf2r*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::sla::caf2r*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *slacLcLcaf2r_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::sla::caf2r*)0x0)->GetClass();
      slacLcLcaf2r_TClassManip(theClass);
   return theClass;
   }

   static void slacLcLcaf2r_TClassManip(TClass* theClass){
      theClass->CreateAttributeMap();
      TDictAttributeMap* attrMap( theClass->GetAttributeMap() );
      attrMap->AddProperty("file_name","sla.hh");
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *slacLcLearth_Dictionary();
   static void slacLcLearth_TClassManip(TClass*);
   static void delete_slacLcLearth(void *p);
   static void deleteArray_slacLcLearth(void *p);
   static void destruct_slacLcLearth(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::sla::earth*)
   {
      ::sla::earth *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::sla::earth));
      static ::ROOT::TGenericClassInfo 
         instance("sla::earth", "sla.hh", 9210,
                  typeid(::sla::earth), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &slacLcLearth_Dictionary, isa_proxy, 4,
                  sizeof(::sla::earth) );
      instance.SetDelete(&delete_slacLcLearth);
      instance.SetDeleteArray(&deleteArray_slacLcLearth);
      instance.SetDestructor(&destruct_slacLcLearth);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::sla::earth*)
   {
      return GenerateInitInstanceLocal((::sla::earth*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::sla::earth*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *slacLcLearth_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::sla::earth*)0x0)->GetClass();
      slacLcLearth_TClassManip(theClass);
   return theClass;
   }

   static void slacLcLearth_TClassManip(TClass* theClass){
      theClass->CreateAttributeMap();
      TDictAttributeMap* attrMap( theClass->GetAttributeMap() );
      attrMap->AddProperty("file_name","sla.hh");
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *slacLcLprenut_Dictionary();
   static void slacLcLprenut_TClassManip(TClass*);
   static void delete_slacLcLprenut(void *p);
   static void deleteArray_slacLcLprenut(void *p);
   static void destruct_slacLcLprenut(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::sla::prenut*)
   {
      ::sla::prenut *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::sla::prenut));
      static ::ROOT::TGenericClassInfo 
         instance("sla::prenut", "sla.hh", 9260,
                  typeid(::sla::prenut), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &slacLcLprenut_Dictionary, isa_proxy, 4,
                  sizeof(::sla::prenut) );
      instance.SetDelete(&delete_slacLcLprenut);
      instance.SetDeleteArray(&deleteArray_slacLcLprenut);
      instance.SetDestructor(&destruct_slacLcLprenut);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::sla::prenut*)
   {
      return GenerateInitInstanceLocal((::sla::prenut*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::sla::prenut*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *slacLcLprenut_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::sla::prenut*)0x0)->GetClass();
      slacLcLprenut_TClassManip(theClass);
   return theClass;
   }

   static void slacLcLprenut_TClassManip(TClass* theClass){
      theClass->CreateAttributeMap();
      TDictAttributeMap* attrMap( theClass->GetAttributeMap() );
      attrMap->AddProperty("file_name","sla.hh");
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *slacLcLxy2xy_Dictionary();
   static void slacLcLxy2xy_TClassManip(TClass*);
   static void delete_slacLcLxy2xy(void *p);
   static void deleteArray_slacLcLxy2xy(void *p);
   static void destruct_slacLcLxy2xy(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::sla::xy2xy*)
   {
      ::sla::xy2xy *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::sla::xy2xy));
      static ::ROOT::TGenericClassInfo 
         instance("sla::xy2xy", "sla.hh", 9340,
                  typeid(::sla::xy2xy), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &slacLcLxy2xy_Dictionary, isa_proxy, 4,
                  sizeof(::sla::xy2xy) );
      instance.SetDelete(&delete_slacLcLxy2xy);
      instance.SetDeleteArray(&deleteArray_slacLcLxy2xy);
      instance.SetDestructor(&destruct_slacLcLxy2xy);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::sla::xy2xy*)
   {
      return GenerateInitInstanceLocal((::sla::xy2xy*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::sla::xy2xy*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *slacLcLxy2xy_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::sla::xy2xy*)0x0)->GetClass();
      slacLcLxy2xy_TClassManip(theClass);
   return theClass;
   }

   static void slacLcLxy2xy_TClassManip(TClass* theClass){
      theClass->CreateAttributeMap();
      TDictAttributeMap* attrMap( theClass->GetAttributeMap() );
      attrMap->AddProperty("file_name","sla.hh");
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *slacLcLue2pv_Dictionary();
   static void slacLcLue2pv_TClassManip(TClass*);
   static void delete_slacLcLue2pv(void *p);
   static void deleteArray_slacLcLue2pv(void *p);
   static void destruct_slacLcLue2pv(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::sla::ue2pv*)
   {
      ::sla::ue2pv *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::sla::ue2pv));
      static ::ROOT::TGenericClassInfo 
         instance("sla::ue2pv", "sla.hh", 9469,
                  typeid(::sla::ue2pv), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &slacLcLue2pv_Dictionary, isa_proxy, 4,
                  sizeof(::sla::ue2pv) );
      instance.SetDelete(&delete_slacLcLue2pv);
      instance.SetDeleteArray(&deleteArray_slacLcLue2pv);
      instance.SetDestructor(&destruct_slacLcLue2pv);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::sla::ue2pv*)
   {
      return GenerateInitInstanceLocal((::sla::ue2pv*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::sla::ue2pv*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *slacLcLue2pv_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::sla::ue2pv*)0x0)->GetClass();
      slacLcLue2pv_TClassManip(theClass);
   return theClass;
   }

   static void slacLcLue2pv_TClassManip(TClass* theClass){
      theClass->CreateAttributeMap();
      TDictAttributeMap* attrMap( theClass->GetAttributeMap() );
      attrMap->AddProperty("file_name","sla.hh");
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *slacLcLsupgal_Dictionary();
   static void slacLcLsupgal_TClassManip(TClass*);
   static void delete_slacLcLsupgal(void *p);
   static void deleteArray_slacLcLsupgal(void *p);
   static void destruct_slacLcLsupgal(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::sla::supgal*)
   {
      ::sla::supgal *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::sla::supgal));
      static ::ROOT::TGenericClassInfo 
         instance("sla::supgal", "sla.hh", 9526,
                  typeid(::sla::supgal), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &slacLcLsupgal_Dictionary, isa_proxy, 4,
                  sizeof(::sla::supgal) );
      instance.SetDelete(&delete_slacLcLsupgal);
      instance.SetDeleteArray(&deleteArray_slacLcLsupgal);
      instance.SetDestructor(&destruct_slacLcLsupgal);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::sla::supgal*)
   {
      return GenerateInitInstanceLocal((::sla::supgal*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::sla::supgal*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *slacLcLsupgal_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::sla::supgal*)0x0)->GetClass();
      slacLcLsupgal_TClassManip(theClass);
   return theClass;
   }

   static void slacLcLsupgal_TClassManip(TClass* theClass){
      theClass->CreateAttributeMap();
      TDictAttributeMap* attrMap( theClass->GetAttributeMap() );
      attrMap->AddProperty("file_name","sla.hh");
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *slacLcLdr2af_Dictionary();
   static void slacLcLdr2af_TClassManip(TClass*);
   static void delete_slacLcLdr2af(void *p);
   static void deleteArray_slacLcLdr2af(void *p);
   static void destruct_slacLcLdr2af(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::sla::dr2af*)
   {
      ::sla::dr2af *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::sla::dr2af));
      static ::ROOT::TGenericClassInfo 
         instance("sla::dr2af", "sla.hh", 9663,
                  typeid(::sla::dr2af), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &slacLcLdr2af_Dictionary, isa_proxy, 4,
                  sizeof(::sla::dr2af) );
      instance.SetDelete(&delete_slacLcLdr2af);
      instance.SetDeleteArray(&deleteArray_slacLcLdr2af);
      instance.SetDestructor(&destruct_slacLcLdr2af);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::sla::dr2af*)
   {
      return GenerateInitInstanceLocal((::sla::dr2af*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::sla::dr2af*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *slacLcLdr2af_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::sla::dr2af*)0x0)->GetClass();
      slacLcLdr2af_TClassManip(theClass);
   return theClass;
   }

   static void slacLcLdr2af_TClassManip(TClass* theClass){
      theClass->CreateAttributeMap();
      TDictAttributeMap* attrMap( theClass->GetAttributeMap() );
      attrMap->AddProperty("file_name","sla.hh");
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *slacLcLaddet_Dictionary();
   static void slacLcLaddet_TClassManip(TClass*);
   static void delete_slacLcLaddet(void *p);
   static void deleteArray_slacLcLaddet(void *p);
   static void destruct_slacLcLaddet(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::sla::addet*)
   {
      ::sla::addet *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::sla::addet));
      static ::ROOT::TGenericClassInfo 
         instance("sla::addet", "sla.hh", 9757,
                  typeid(::sla::addet), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &slacLcLaddet_Dictionary, isa_proxy, 4,
                  sizeof(::sla::addet) );
      instance.SetDelete(&delete_slacLcLaddet);
      instance.SetDeleteArray(&deleteArray_slacLcLaddet);
      instance.SetDestructor(&destruct_slacLcLaddet);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::sla::addet*)
   {
      return GenerateInitInstanceLocal((::sla::addet*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::sla::addet*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *slacLcLaddet_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::sla::addet*)0x0)->GetClass();
      slacLcLaddet_TClassManip(theClass);
   return theClass;
   }

   static void slacLcLaddet_TClassManip(TClass* theClass){
      theClass->CreateAttributeMap();
      TDictAttributeMap* attrMap( theClass->GetAttributeMap() );
      attrMap->AddProperty("file_name","sla.hh");
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *slacLcLrefv_Dictionary();
   static void slacLcLrefv_TClassManip(TClass*);
   static void delete_slacLcLrefv(void *p);
   static void deleteArray_slacLcLrefv(void *p);
   static void destruct_slacLcLrefv(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::sla::refv*)
   {
      ::sla::refv *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::sla::refv));
      static ::ROOT::TGenericClassInfo 
         instance("sla::refv", "sla.hh", 9855,
                  typeid(::sla::refv), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &slacLcLrefv_Dictionary, isa_proxy, 4,
                  sizeof(::sla::refv) );
      instance.SetDelete(&delete_slacLcLrefv);
      instance.SetDeleteArray(&deleteArray_slacLcLrefv);
      instance.SetDestructor(&destruct_slacLcLrefv);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::sla::refv*)
   {
      return GenerateInitInstanceLocal((::sla::refv*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::sla::refv*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *slacLcLrefv_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::sla::refv*)0x0)->GetClass();
      slacLcLrefv_TClassManip(theClass);
   return theClass;
   }

   static void slacLcLrefv_TClassManip(TClass* theClass){
      theClass->CreateAttributeMap();
      TDictAttributeMap* attrMap( theClass->GetAttributeMap() );
      attrMap->AddProperty("file_name","sla.hh");
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *slacLcL_atmt_Dictionary();
   static void slacLcL_atmt_TClassManip(TClass*);
   static void delete_slacLcL_atmt(void *p);
   static void deleteArray_slacLcL_atmt(void *p);
   static void destruct_slacLcL_atmt(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::sla::_atmt*)
   {
      ::sla::_atmt *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::sla::_atmt));
      static ::ROOT::TGenericClassInfo 
         instance("sla::_atmt", "sla.hh", 9940,
                  typeid(::sla::_atmt), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &slacLcL_atmt_Dictionary, isa_proxy, 4,
                  sizeof(::sla::_atmt) );
      instance.SetDelete(&delete_slacLcL_atmt);
      instance.SetDeleteArray(&deleteArray_slacLcL_atmt);
      instance.SetDestructor(&destruct_slacLcL_atmt);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::sla::_atmt*)
   {
      return GenerateInitInstanceLocal((::sla::_atmt*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::sla::_atmt*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *slacLcL_atmt_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::sla::_atmt*)0x0)->GetClass();
      slacLcL_atmt_TClassManip(theClass);
   return theClass;
   }

   static void slacLcL_atmt_TClassManip(TClass* theClass){
      theClass->CreateAttributeMap();
      TDictAttributeMap* attrMap( theClass->GetAttributeMap() );
      attrMap->AddProperty("file_name","sla.hh");
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *slacLcLcc62s_Dictionary();
   static void slacLcLcc62s_TClassManip(TClass*);
   static void delete_slacLcLcc62s(void *p);
   static void deleteArray_slacLcLcc62s(void *p);
   static void destruct_slacLcLcc62s(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::sla::cc62s*)
   {
      ::sla::cc62s *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::sla::cc62s));
      static ::ROOT::TGenericClassInfo 
         instance("sla::cc62s", "sla.hh", 9984,
                  typeid(::sla::cc62s), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &slacLcLcc62s_Dictionary, isa_proxy, 4,
                  sizeof(::sla::cc62s) );
      instance.SetDelete(&delete_slacLcLcc62s);
      instance.SetDeleteArray(&deleteArray_slacLcLcc62s);
      instance.SetDestructor(&destruct_slacLcLcc62s);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::sla::cc62s*)
   {
      return GenerateInitInstanceLocal((::sla::cc62s*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::sla::cc62s*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *slacLcLcc62s_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::sla::cc62s*)0x0)->GetClass();
      slacLcLcc62s_TClassManip(theClass);
   return theClass;
   }

   static void slacLcLcc62s_TClassManip(TClass* theClass){
      theClass->CreateAttributeMap();
      TDictAttributeMap* attrMap( theClass->GetAttributeMap() );
      attrMap->AddProperty("file_name","sla.hh");
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *slacLcLsubet_Dictionary();
   static void slacLcLsubet_TClassManip(TClass*);
   static void delete_slacLcLsubet(void *p);
   static void deleteArray_slacLcLsubet(void *p);
   static void destruct_slacLcLsubet(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::sla::subet*)
   {
      ::sla::subet *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::sla::subet));
      static ::ROOT::TGenericClassInfo 
         instance("sla::subet", "sla.hh", 10039,
                  typeid(::sla::subet), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &slacLcLsubet_Dictionary, isa_proxy, 4,
                  sizeof(::sla::subet) );
      instance.SetDelete(&delete_slacLcLsubet);
      instance.SetDeleteArray(&deleteArray_slacLcLsubet);
      instance.SetDestructor(&destruct_slacLcLsubet);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::sla::subet*)
   {
      return GenerateInitInstanceLocal((::sla::subet*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::sla::subet*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *slacLcLsubet_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::sla::subet*)0x0)->GetClass();
      slacLcLsubet_TClassManip(theClass);
   return theClass;
   }

   static void slacLcLsubet_TClassManip(TClass* theClass){
      theClass->CreateAttributeMap();
      TDictAttributeMap* attrMap( theClass->GetAttributeMap() );
      attrMap->AddProperty("file_name","sla.hh");
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *slacLcLcldj_Dictionary();
   static void slacLcLcldj_TClassManip(TClass*);
   static void delete_slacLcLcldj(void *p);
   static void deleteArray_slacLcLcldj(void *p);
   static void destruct_slacLcLcldj(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::sla::cldj*)
   {
      ::sla::cldj *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::sla::cldj));
      static ::ROOT::TGenericClassInfo 
         instance("sla::cldj", "sla.hh", 10086,
                  typeid(::sla::cldj), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &slacLcLcldj_Dictionary, isa_proxy, 4,
                  sizeof(::sla::cldj) );
      instance.SetDelete(&delete_slacLcLcldj);
      instance.SetDeleteArray(&deleteArray_slacLcLcldj);
      instance.SetDestructor(&destruct_slacLcLcldj);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::sla::cldj*)
   {
      return GenerateInitInstanceLocal((::sla::cldj*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::sla::cldj*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *slacLcLcldj_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::sla::cldj*)0x0)->GetClass();
      slacLcLcldj_TClassManip(theClass);
   return theClass;
   }

   static void slacLcLcldj_TClassManip(TClass* theClass){
      theClass->CreateAttributeMap();
      TDictAttributeMap* attrMap( theClass->GetAttributeMap() );
      attrMap->AddProperty("file_name","sla.hh");
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *slacLcLdtf2r_Dictionary();
   static void slacLcLdtf2r_TClassManip(TClass*);
   static void delete_slacLcLdtf2r(void *p);
   static void deleteArray_slacLcLdtf2r(void *p);
   static void destruct_slacLcLdtf2r(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::sla::dtf2r*)
   {
      ::sla::dtf2r *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::sla::dtf2r));
      static ::ROOT::TGenericClassInfo 
         instance("sla::dtf2r", "sla.hh", 10139,
                  typeid(::sla::dtf2r), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &slacLcLdtf2r_Dictionary, isa_proxy, 4,
                  sizeof(::sla::dtf2r) );
      instance.SetDelete(&delete_slacLcLdtf2r);
      instance.SetDeleteArray(&deleteArray_slacLcLdtf2r);
      instance.SetDestructor(&destruct_slacLcLdtf2r);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::sla::dtf2r*)
   {
      return GenerateInitInstanceLocal((::sla::dtf2r*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::sla::dtf2r*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *slacLcLdtf2r_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::sla::dtf2r*)0x0)->GetClass();
      slacLcLdtf2r_TClassManip(theClass);
   return theClass;
   }

   static void slacLcLdtf2r_TClassManip(TClass* theClass){
      theClass->CreateAttributeMap();
      TDictAttributeMap* attrMap( theClass->GetAttributeMap() );
      attrMap->AddProperty("file_name","sla.hh");
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *slacLcLaop_Dictionary();
   static void slacLcLaop_TClassManip(TClass*);
   static void delete_slacLcLaop(void *p);
   static void deleteArray_slacLcLaop(void *p);
   static void destruct_slacLcLaop(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::sla::aop*)
   {
      ::sla::aop *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::sla::aop));
      static ::ROOT::TGenericClassInfo 
         instance("sla::aop", "sla.hh", 10317,
                  typeid(::sla::aop), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &slacLcLaop_Dictionary, isa_proxy, 4,
                  sizeof(::sla::aop) );
      instance.SetDelete(&delete_slacLcLaop);
      instance.SetDeleteArray(&deleteArray_slacLcLaop);
      instance.SetDestructor(&destruct_slacLcLaop);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::sla::aop*)
   {
      return GenerateInitInstanceLocal((::sla::aop*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::sla::aop*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *slacLcLaop_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::sla::aop*)0x0)->GetClass();
      slacLcLaop_TClassManip(theClass);
   return theClass;
   }

   static void slacLcLaop_TClassManip(TClass* theClass){
      theClass->CreateAttributeMap();
      TDictAttributeMap* attrMap( theClass->GetAttributeMap() );
      attrMap->AddProperty("file_name","sla.hh");
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *slacLcLrdplan_Dictionary();
   static void slacLcLrdplan_TClassManip(TClass*);
   static void delete_slacLcLrdplan(void *p);
   static void deleteArray_slacLcLrdplan(void *p);
   static void destruct_slacLcLrdplan(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::sla::rdplan*)
   {
      ::sla::rdplan *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::sla::rdplan));
      static ::ROOT::TGenericClassInfo 
         instance("sla::rdplan", "sla.hh", 10442,
                  typeid(::sla::rdplan), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &slacLcLrdplan_Dictionary, isa_proxy, 4,
                  sizeof(::sla::rdplan) );
      instance.SetDelete(&delete_slacLcLrdplan);
      instance.SetDeleteArray(&deleteArray_slacLcLrdplan);
      instance.SetDestructor(&destruct_slacLcLrdplan);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::sla::rdplan*)
   {
      return GenerateInitInstanceLocal((::sla::rdplan*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::sla::rdplan*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *slacLcLrdplan_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::sla::rdplan*)0x0)->GetClass();
      slacLcLrdplan_TClassManip(theClass);
   return theClass;
   }

   static void slacLcLrdplan_TClassManip(TClass* theClass){
      theClass->CreateAttributeMap();
      TDictAttributeMap* attrMap( theClass->GetAttributeMap() );
      attrMap->AddProperty("file_name","sla.hh");
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *slacLcLdbjin_Dictionary();
   static void slacLcLdbjin_TClassManip(TClass*);
   static void delete_slacLcLdbjin(void *p);
   static void deleteArray_slacLcLdbjin(void *p);
   static void destruct_slacLcLdbjin(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::sla::dbjin*)
   {
      ::sla::dbjin *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::sla::dbjin));
      static ::ROOT::TGenericClassInfo 
         instance("sla::dbjin", "sla.hh", 10508,
                  typeid(::sla::dbjin), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &slacLcLdbjin_Dictionary, isa_proxy, 4,
                  sizeof(::sla::dbjin) );
      instance.SetDelete(&delete_slacLcLdbjin);
      instance.SetDeleteArray(&deleteArray_slacLcLdbjin);
      instance.SetDestructor(&destruct_slacLcLdbjin);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::sla::dbjin*)
   {
      return GenerateInitInstanceLocal((::sla::dbjin*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::sla::dbjin*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *slacLcLdbjin_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::sla::dbjin*)0x0)->GetClass();
      slacLcLdbjin_TClassManip(theClass);
   return theClass;
   }

   static void slacLcLdbjin_TClassManip(TClass* theClass){
      theClass->CreateAttributeMap();
      TDictAttributeMap* attrMap( theClass->GetAttributeMap() );
      attrMap->AddProperty("file_name","sla.hh");
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *slacLcLtpv2c_Dictionary();
   static void slacLcLtpv2c_TClassManip(TClass*);
   static void delete_slacLcLtpv2c(void *p);
   static void deleteArray_slacLcLtpv2c(void *p);
   static void destruct_slacLcLtpv2c(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::sla::tpv2c*)
   {
      ::sla::tpv2c *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::sla::tpv2c));
      static ::ROOT::TGenericClassInfo 
         instance("sla::tpv2c", "sla.hh", 10573,
                  typeid(::sla::tpv2c), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &slacLcLtpv2c_Dictionary, isa_proxy, 4,
                  sizeof(::sla::tpv2c) );
      instance.SetDelete(&delete_slacLcLtpv2c);
      instance.SetDeleteArray(&deleteArray_slacLcLtpv2c);
      instance.SetDestructor(&destruct_slacLcLtpv2c);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::sla::tpv2c*)
   {
      return GenerateInitInstanceLocal((::sla::tpv2c*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::sla::tpv2c*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *slacLcLtpv2c_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::sla::tpv2c*)0x0)->GetClass();
      slacLcLtpv2c_TClassManip(theClass);
   return theClass;
   }

   static void slacLcLtpv2c_TClassManip(TClass* theClass){
      theClass->CreateAttributeMap();
      TDictAttributeMap* attrMap( theClass->GetAttributeMap() );
      attrMap->AddProperty("file_name","sla.hh");
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *slacLcLoapqk_Dictionary();
   static void slacLcLoapqk_TClassManip(TClass*);
   static void delete_slacLcLoapqk(void *p);
   static void deleteArray_slacLcLoapqk(void *p);
   static void destruct_slacLcLoapqk(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::sla::oapqk*)
   {
      ::sla::oapqk *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::sla::oapqk));
      static ::ROOT::TGenericClassInfo 
         instance("sla::oapqk", "sla.hh", 10701,
                  typeid(::sla::oapqk), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &slacLcLoapqk_Dictionary, isa_proxy, 4,
                  sizeof(::sla::oapqk) );
      instance.SetDelete(&delete_slacLcLoapqk);
      instance.SetDeleteArray(&deleteArray_slacLcLoapqk);
      instance.SetDestructor(&destruct_slacLcLoapqk);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::sla::oapqk*)
   {
      return GenerateInitInstanceLocal((::sla::oapqk*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::sla::oapqk*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *slacLcLoapqk_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::sla::oapqk*)0x0)->GetClass();
      slacLcLoapqk_TClassManip(theClass);
   return theClass;
   }

   static void slacLcLoapqk_TClassManip(TClass* theClass){
      theClass->CreateAttributeMap();
      TDictAttributeMap* attrMap( theClass->GetAttributeMap() );
      attrMap->AddProperty("file_name","sla.hh");
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *slacLcLpda2h_Dictionary();
   static void slacLcLpda2h_TClassManip(TClass*);
   static void delete_slacLcLpda2h(void *p);
   static void deleteArray_slacLcLpda2h(void *p);
   static void destruct_slacLcLpda2h(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::sla::pda2h*)
   {
      ::sla::pda2h *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::sla::pda2h));
      static ::ROOT::TGenericClassInfo 
         instance("sla::pda2h", "sla.hh", 10748,
                  typeid(::sla::pda2h), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &slacLcLpda2h_Dictionary, isa_proxy, 4,
                  sizeof(::sla::pda2h) );
      instance.SetDelete(&delete_slacLcLpda2h);
      instance.SetDeleteArray(&deleteArray_slacLcLpda2h);
      instance.SetDestructor(&destruct_slacLcLpda2h);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::sla::pda2h*)
   {
      return GenerateInitInstanceLocal((::sla::pda2h*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::sla::pda2h*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *slacLcLpda2h_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::sla::pda2h*)0x0)->GetClass();
      slacLcLpda2h_TClassManip(theClass);
   return theClass;
   }

   static void slacLcLpda2h_TClassManip(TClass* theClass){
      theClass->CreateAttributeMap();
      TDictAttributeMap* attrMap( theClass->GetAttributeMap() );
      attrMap->AddProperty("file_name","sla.hh");
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *slacLcLaopqk_Dictionary();
   static void slacLcLaopqk_TClassManip(TClass*);
   static void delete_slacLcLaopqk(void *p);
   static void deleteArray_slacLcLaopqk(void *p);
   static void destruct_slacLcLaopqk(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::sla::aopqk*)
   {
      ::sla::aopqk *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::sla::aopqk));
      static ::ROOT::TGenericClassInfo 
         instance("sla::aopqk", "sla.hh", 10893,
                  typeid(::sla::aopqk), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &slacLcLaopqk_Dictionary, isa_proxy, 4,
                  sizeof(::sla::aopqk) );
      instance.SetDelete(&delete_slacLcLaopqk);
      instance.SetDeleteArray(&deleteArray_slacLcLaopqk);
      instance.SetDestructor(&destruct_slacLcLaopqk);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::sla::aopqk*)
   {
      return GenerateInitInstanceLocal((::sla::aopqk*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::sla::aopqk*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *slacLcLaopqk_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::sla::aopqk*)0x0)->GetClass();
      slacLcLaopqk_TClassManip(theClass);
   return theClass;
   }

   static void slacLcLaopqk_TClassManip(TClass* theClass){
      theClass->CreateAttributeMap();
      TDictAttributeMap* attrMap( theClass->GetAttributeMap() );
      attrMap->AddProperty("file_name","sla.hh");
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *slacLcLpm_Dictionary();
   static void slacLcLpm_TClassManip(TClass*);
   static void delete_slacLcLpm(void *p);
   static void deleteArray_slacLcLpm(void *p);
   static void destruct_slacLcLpm(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::sla::pm*)
   {
      ::sla::pm *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::sla::pm));
      static ::ROOT::TGenericClassInfo 
         instance("sla::pm", "sla.hh", 10958,
                  typeid(::sla::pm), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &slacLcLpm_Dictionary, isa_proxy, 4,
                  sizeof(::sla::pm) );
      instance.SetDelete(&delete_slacLcLpm);
      instance.SetDeleteArray(&deleteArray_slacLcLpm);
      instance.SetDestructor(&destruct_slacLcLpm);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::sla::pm*)
   {
      return GenerateInitInstanceLocal((::sla::pm*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::sla::pm*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *slacLcLpm_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::sla::pm*)0x0)->GetClass();
      slacLcLpm_TClassManip(theClass);
   return theClass;
   }

   static void slacLcLpm_TClassManip(TClass* theClass){
      theClass->CreateAttributeMap();
      TDictAttributeMap* attrMap( theClass->GetAttributeMap() );
      attrMap->AddProperty("file_name","sla.hh");
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *slacLcLintin_Dictionary();
   static void slacLcLintin_TClassManip(TClass*);
   static void delete_slacLcLintin(void *p);
   static void deleteArray_slacLcLintin(void *p);
   static void destruct_slacLcLintin(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::sla::intin*)
   {
      ::sla::intin *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::sla::intin));
      static ::ROOT::TGenericClassInfo 
         instance("sla::intin", "sla.hh", 11100,
                  typeid(::sla::intin), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &slacLcLintin_Dictionary, isa_proxy, 4,
                  sizeof(::sla::intin) );
      instance.SetDelete(&delete_slacLcLintin);
      instance.SetDeleteArray(&deleteArray_slacLcLintin);
      instance.SetDestructor(&destruct_slacLcLintin);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::sla::intin*)
   {
      return GenerateInitInstanceLocal((::sla::intin*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::sla::intin*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *slacLcLintin_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::sla::intin*)0x0)->GetClass();
      slacLcLintin_TClassManip(theClass);
   return theClass;
   }

   static void slacLcLintin_TClassManip(TClass* theClass){
      theClass->CreateAttributeMap();
      TDictAttributeMap* attrMap( theClass->GetAttributeMap() );
      attrMap->AddProperty("file_name","sla.hh");
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *slacLcLcr2tf_Dictionary();
   static void slacLcLcr2tf_TClassManip(TClass*);
   static void delete_slacLcLcr2tf(void *p);
   static void deleteArray_slacLcLcr2tf(void *p);
   static void destruct_slacLcLcr2tf(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::sla::cr2tf*)
   {
      ::sla::cr2tf *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::sla::cr2tf));
      static ::ROOT::TGenericClassInfo 
         instance("sla::cr2tf", "sla.hh", 11160,
                  typeid(::sla::cr2tf), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &slacLcLcr2tf_Dictionary, isa_proxy, 4,
                  sizeof(::sla::cr2tf) );
      instance.SetDelete(&delete_slacLcLcr2tf);
      instance.SetDeleteArray(&deleteArray_slacLcLcr2tf);
      instance.SetDestructor(&destruct_slacLcLcr2tf);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::sla::cr2tf*)
   {
      return GenerateInitInstanceLocal((::sla::cr2tf*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::sla::cr2tf*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *slacLcLcr2tf_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::sla::cr2tf*)0x0)->GetClass();
      slacLcLcr2tf_TClassManip(theClass);
   return theClass;
   }

   static void slacLcLcr2tf_TClassManip(TClass* theClass){
      theClass->CreateAttributeMap();
      TDictAttributeMap* attrMap( theClass->GetAttributeMap() );
      attrMap->AddProperty("file_name","sla.hh");
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *slacLcLplanet_Dictionary();
   static void slacLcLplanet_TClassManip(TClass*);
   static void delete_slacLcLplanet(void *p);
   static void deleteArray_slacLcLplanet(void *p);
   static void destruct_slacLcLplanet(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::sla::planet*)
   {
      ::sla::planet *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::sla::planet));
      static ::ROOT::TGenericClassInfo 
         instance("sla::planet", "sla.hh", 11304,
                  typeid(::sla::planet), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &slacLcLplanet_Dictionary, isa_proxy, 4,
                  sizeof(::sla::planet) );
      instance.SetDelete(&delete_slacLcLplanet);
      instance.SetDeleteArray(&deleteArray_slacLcLplanet);
      instance.SetDestructor(&destruct_slacLcLplanet);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::sla::planet*)
   {
      return GenerateInitInstanceLocal((::sla::planet*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::sla::planet*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *slacLcLplanet_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::sla::planet*)0x0)->GetClass();
      slacLcLplanet_TClassManip(theClass);
   return theClass;
   }

   static void slacLcLplanet_TClassManip(TClass* theClass){
      theClass->CreateAttributeMap();
      TDictAttributeMap* attrMap( theClass->GetAttributeMap() );
      attrMap->AddProperty("file_name","sla.hh");
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *slacLcLvxv_Dictionary();
   static void slacLcLvxv_TClassManip(TClass*);
   static void delete_slacLcLvxv(void *p);
   static void deleteArray_slacLcLvxv(void *p);
   static void destruct_slacLcLvxv(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::sla::vxv*)
   {
      ::sla::vxv *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::sla::vxv));
      static ::ROOT::TGenericClassInfo 
         instance("sla::vxv", "sla.hh", 11343,
                  typeid(::sla::vxv), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &slacLcLvxv_Dictionary, isa_proxy, 4,
                  sizeof(::sla::vxv) );
      instance.SetDelete(&delete_slacLcLvxv);
      instance.SetDeleteArray(&deleteArray_slacLcLvxv);
      instance.SetDestructor(&destruct_slacLcLvxv);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::sla::vxv*)
   {
      return GenerateInitInstanceLocal((::sla::vxv*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::sla::vxv*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *slacLcLvxv_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::sla::vxv*)0x0)->GetClass();
      slacLcLvxv_TClassManip(theClass);
   return theClass;
   }

   static void slacLcLvxv_TClassManip(TClass* theClass){
      theClass->CreateAttributeMap();
      TDictAttributeMap* attrMap( theClass->GetAttributeMap() );
      attrMap->AddProperty("file_name","sla.hh");
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *slacLcLpcd_Dictionary();
   static void slacLcLpcd_TClassManip(TClass*);
   static void delete_slacLcLpcd(void *p);
   static void deleteArray_slacLcLpcd(void *p);
   static void destruct_slacLcLpcd(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::sla::pcd*)
   {
      ::sla::pcd *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::sla::pcd));
      static ::ROOT::TGenericClassInfo 
         instance("sla::pcd", "sla.hh", 11454,
                  typeid(::sla::pcd), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &slacLcLpcd_Dictionary, isa_proxy, 4,
                  sizeof(::sla::pcd) );
      instance.SetDelete(&delete_slacLcLpcd);
      instance.SetDeleteArray(&deleteArray_slacLcLpcd);
      instance.SetDestructor(&destruct_slacLcLpcd);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::sla::pcd*)
   {
      return GenerateInitInstanceLocal((::sla::pcd*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::sla::pcd*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *slacLcLpcd_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::sla::pcd*)0x0)->GetClass();
      slacLcLpcd_TClassManip(theClass);
   return theClass;
   }

   static void slacLcLpcd_TClassManip(TClass* theClass){
      theClass->CreateAttributeMap();
      TDictAttributeMap* attrMap( theClass->GetAttributeMap() );
      attrMap->AddProperty("file_name","sla.hh");
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *slacLcLecor_Dictionary();
   static void slacLcLecor_TClassManip(TClass*);
   static void delete_slacLcLecor(void *p);
   static void deleteArray_slacLcLecor(void *p);
   static void destruct_slacLcLecor(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::sla::ecor*)
   {
      ::sla::ecor *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::sla::ecor));
      static ::ROOT::TGenericClassInfo 
         instance("sla::ecor", "sla.hh", 11522,
                  typeid(::sla::ecor), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &slacLcLecor_Dictionary, isa_proxy, 4,
                  sizeof(::sla::ecor) );
      instance.SetDelete(&delete_slacLcLecor);
      instance.SetDeleteArray(&deleteArray_slacLcLecor);
      instance.SetDestructor(&destruct_slacLcLecor);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::sla::ecor*)
   {
      return GenerateInitInstanceLocal((::sla::ecor*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::sla::ecor*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *slacLcLecor_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::sla::ecor*)0x0)->GetClass();
      slacLcLecor_TClassManip(theClass);
   return theClass;
   }

   static void slacLcLecor_TClassManip(TClass* theClass){
      theClass->CreateAttributeMap();
      TDictAttributeMap* attrMap( theClass->GetAttributeMap() );
      attrMap->AddProperty("file_name","sla.hh");
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *slacLcLflotin_Dictionary();
   static void slacLcLflotin_TClassManip(TClass*);
   static void delete_slacLcLflotin(void *p);
   static void deleteArray_slacLcLflotin(void *p);
   static void destruct_slacLcLflotin(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::sla::flotin*)
   {
      ::sla::flotin *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::sla::flotin));
      static ::ROOT::TGenericClassInfo 
         instance("sla::flotin", "sla.hh", 11654,
                  typeid(::sla::flotin), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &slacLcLflotin_Dictionary, isa_proxy, 4,
                  sizeof(::sla::flotin) );
      instance.SetDelete(&delete_slacLcLflotin);
      instance.SetDeleteArray(&deleteArray_slacLcLflotin);
      instance.SetDestructor(&destruct_slacLcLflotin);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::sla::flotin*)
   {
      return GenerateInitInstanceLocal((::sla::flotin*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::sla::flotin*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *slacLcLflotin_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::sla::flotin*)0x0)->GetClass();
      slacLcLflotin_TClassManip(theClass);
   return theClass;
   }

   static void slacLcLflotin_TClassManip(TClass* theClass){
      theClass->CreateAttributeMap();
      TDictAttributeMap* attrMap( theClass->GetAttributeMap() );
      attrMap->AddProperty("file_name","sla.hh");
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *slacLcLdtp2v_Dictionary();
   static void slacLcLdtp2v_TClassManip(TClass*);
   static void delete_slacLcLdtp2v(void *p);
   static void deleteArray_slacLcLdtp2v(void *p);
   static void destruct_slacLcLdtp2v(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::sla::dtp2v*)
   {
      ::sla::dtp2v *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::sla::dtp2v));
      static ::ROOT::TGenericClassInfo 
         instance("sla::dtp2v", "sla.hh", 11708,
                  typeid(::sla::dtp2v), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &slacLcLdtp2v_Dictionary, isa_proxy, 4,
                  sizeof(::sla::dtp2v) );
      instance.SetDelete(&delete_slacLcLdtp2v);
      instance.SetDeleteArray(&deleteArray_slacLcLdtp2v);
      instance.SetDestructor(&destruct_slacLcLdtp2v);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::sla::dtp2v*)
   {
      return GenerateInitInstanceLocal((::sla::dtp2v*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::sla::dtp2v*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *slacLcLdtp2v_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::sla::dtp2v*)0x0)->GetClass();
      slacLcLdtp2v_TClassManip(theClass);
   return theClass;
   }

   static void slacLcLdtp2v_TClassManip(TClass* theClass){
      theClass->CreateAttributeMap();
      TDictAttributeMap* attrMap( theClass->GetAttributeMap() );
      attrMap->AddProperty("file_name","sla.hh");
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *slacLcLe2h_Dictionary();
   static void slacLcLe2h_TClassManip(TClass*);
   static void delete_slacLcLe2h(void *p);
   static void deleteArray_slacLcLe2h(void *p);
   static void destruct_slacLcLe2h(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::sla::e2h*)
   {
      ::sla::e2h *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::sla::e2h));
      static ::ROOT::TGenericClassInfo 
         instance("sla::e2h", "sla.hh", 11781,
                  typeid(::sla::e2h), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &slacLcLe2h_Dictionary, isa_proxy, 4,
                  sizeof(::sla::e2h) );
      instance.SetDelete(&delete_slacLcLe2h);
      instance.SetDeleteArray(&deleteArray_slacLcLe2h);
      instance.SetDestructor(&destruct_slacLcLe2h);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::sla::e2h*)
   {
      return GenerateInitInstanceLocal((::sla::e2h*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::sla::e2h*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *slacLcLe2h_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::sla::e2h*)0x0)->GetClass();
      slacLcLe2h_TClassManip(theClass);
   return theClass;
   }

   static void slacLcLe2h_TClassManip(TClass* theClass){
      theClass->CreateAttributeMap();
      TDictAttributeMap* attrMap( theClass->GetAttributeMap() );
      attrMap->AddProperty("file_name","sla.hh");
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *slacLcLfk524_Dictionary();
   static void slacLcLfk524_TClassManip(TClass*);
   static void delete_slacLcLfk524(void *p);
   static void deleteArray_slacLcLfk524(void *p);
   static void destruct_slacLcLfk524(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::sla::fk524*)
   {
      ::sla::fk524 *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::sla::fk524));
      static ::ROOT::TGenericClassInfo 
         instance("sla::fk524", "sla.hh", 11875,
                  typeid(::sla::fk524), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &slacLcLfk524_Dictionary, isa_proxy, 4,
                  sizeof(::sla::fk524) );
      instance.SetDelete(&delete_slacLcLfk524);
      instance.SetDeleteArray(&deleteArray_slacLcLfk524);
      instance.SetDestructor(&destruct_slacLcLfk524);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::sla::fk524*)
   {
      return GenerateInitInstanceLocal((::sla::fk524*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::sla::fk524*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *slacLcLfk524_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::sla::fk524*)0x0)->GetClass();
      slacLcLfk524_TClassManip(theClass);
   return theClass;
   }

   static void slacLcLfk524_TClassManip(TClass* theClass){
      theClass->CreateAttributeMap();
      TDictAttributeMap* attrMap( theClass->GetAttributeMap() );
      attrMap->AddProperty("file_name","sla.hh");
   }

} // end of namespace ROOT

namespace ROOT {
   // Wrapper around operator delete
   static void delete_slacLcL_pointablelEintgR(void *p) {
      delete ((::sla::_pointable<int>*)p);
   }
   static void deleteArray_slacLcL_pointablelEintgR(void *p) {
      delete [] ((::sla::_pointable<int>*)p);
   }
   static void destruct_slacLcL_pointablelEintgR(void *p) {
      typedef ::sla::_pointable<int> current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::sla::_pointable<int>

namespace ROOT {
   // Wrapper around operator delete
   static void delete_slacLcLpv2el(void *p) {
      delete ((::sla::pv2el*)p);
   }
   static void deleteArray_slacLcLpv2el(void *p) {
      delete [] ((::sla::pv2el*)p);
   }
   static void destruct_slacLcLpv2el(void *p) {
      typedef ::sla::pv2el current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::sla::pv2el

namespace ROOT {
   // Wrapper around operator delete
   static void delete_slacLcLgeoc(void *p) {
      delete ((::sla::geoc*)p);
   }
   static void deleteArray_slacLcLgeoc(void *p) {
      delete [] ((::sla::geoc*)p);
   }
   static void destruct_slacLcLgeoc(void *p) {
      typedef ::sla::geoc current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::sla::geoc

namespace ROOT {
   // Wrapper around operator delete
   static void delete_slacLcLampqk(void *p) {
      delete ((::sla::ampqk*)p);
   }
   static void deleteArray_slacLcLampqk(void *p) {
      delete [] ((::sla::ampqk*)p);
   }
   static void destruct_slacLcLampqk(void *p) {
      typedef ::sla::ampqk current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::sla::ampqk

namespace ROOT {
   // Wrapper around operator delete
   static void delete_slacLcLaoppat(void *p) {
      delete ((::sla::aoppat*)p);
   }
   static void deleteArray_slacLcLaoppat(void *p) {
      delete [] ((::sla::aoppat*)p);
   }
   static void destruct_slacLcLaoppat(void *p) {
      typedef ::sla::aoppat current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::sla::aoppat

namespace ROOT {
   // Wrapper around operator delete
   static void delete_slacLcLdafin(void *p) {
      delete ((::sla::dafin*)p);
   }
   static void deleteArray_slacLcLdafin(void *p) {
      delete [] ((::sla::dafin*)p);
   }
   static void destruct_slacLcLdafin(void *p) {
      typedef ::sla::dafin current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::sla::dafin

namespace ROOT {
   // Wrapper around operator delete
   static void delete_slacLcLecmat(void *p) {
      delete ((::sla::ecmat*)p);
   }
   static void deleteArray_slacLcLecmat(void *p) {
      delete [] ((::sla::ecmat*)p);
   }
   static void destruct_slacLcLecmat(void *p) {
      typedef ::sla::ecmat current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::sla::ecmat

namespace ROOT {
   // Wrapper around operator delete
   static void delete_slacLcLamp(void *p) {
      delete ((::sla::amp*)p);
   }
   static void deleteArray_slacLcLamp(void *p) {
      delete [] ((::sla::amp*)p);
   }
   static void destruct_slacLcLamp(void *p) {
      typedef ::sla::amp current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::sla::amp

namespace ROOT {
   // Wrapper around operator delete
   static void delete_slacLcLtp2v(void *p) {
      delete ((::sla::tp2v*)p);
   }
   static void deleteArray_slacLcLtp2v(void *p) {
      delete [] ((::sla::tp2v*)p);
   }
   static void destruct_slacLcLtp2v(void *p) {
      typedef ::sla::tp2v current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::sla::tp2v

namespace ROOT {
   // Wrapper around operator delete
   static void delete_slacLcLrefz(void *p) {
      delete ((::sla::refz*)p);
   }
   static void deleteArray_slacLcLrefz(void *p) {
      delete [] ((::sla::refz*)p);
   }
   static void destruct_slacLcLrefz(void *p) {
      typedef ::sla::refz current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::sla::refz

namespace ROOT {
   // Wrapper around operator delete
   static void delete_slacLcLcaldj(void *p) {
      delete ((::sla::caldj*)p);
   }
   static void deleteArray_slacLcLcaldj(void *p) {
      delete [] ((::sla::caldj*)p);
   }
   static void destruct_slacLcLcaldj(void *p) {
      typedef ::sla::caldj current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::sla::caldj

namespace ROOT {
   // Wrapper around operator delete
   static void delete_slacLcLcalyd(void *p) {
      delete ((::sla::calyd*)p);
   }
   static void deleteArray_slacLcLcalyd(void *p) {
      delete [] ((::sla::calyd*)p);
   }
   static void destruct_slacLcLcalyd(void *p) {
      typedef ::sla::calyd current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::sla::calyd

namespace ROOT {
   // Wrapper around operator delete
   static void delete_slacLcLmxv(void *p) {
      delete ((::sla::mxv*)p);
   }
   static void deleteArray_slacLcLmxv(void *p) {
      delete [] ((::sla::mxv*)p);
   }
   static void destruct_slacLcLmxv(void *p) {
      typedef ::sla::mxv current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::sla::mxv

namespace ROOT {
   // Wrapper around operator delete
   static void delete_slacLcLepv(void *p) {
      delete ((::sla::epv*)p);
   }
   static void deleteArray_slacLcLepv(void *p) {
      delete [] ((::sla::epv*)p);
   }
   static void destruct_slacLcLepv(void *p) {
      typedef ::sla::epv current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::sla::epv

namespace ROOT {
   // Wrapper around operator delete
   static void delete_slacLcLdtf2d(void *p) {
      delete ((::sla::dtf2d*)p);
   }
   static void deleteArray_slacLcLdtf2d(void *p) {
      delete [] ((::sla::dtf2d*)p);
   }
   static void destruct_slacLcLdtf2d(void *p) {
      typedef ::sla::dtf2d current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::sla::dtf2d

namespace ROOT {
   // Wrapper around operator delete
   static void delete_slacLcLgalsup(void *p) {
      delete ((::sla::galsup*)p);
   }
   static void deleteArray_slacLcLgalsup(void *p) {
      delete [] ((::sla::galsup*)p);
   }
   static void destruct_slacLcLgalsup(void *p) {
      typedef ::sla::galsup current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::sla::galsup

namespace ROOT {
   // Wrapper around operator delete
   static void delete_slacLcLpreces(void *p) {
      delete ((::sla::preces*)p);
   }
   static void deleteArray_slacLcLpreces(void *p) {
      delete [] ((::sla::preces*)p);
   }
   static void destruct_slacLcLpreces(void *p) {
      typedef ::sla::preces current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::sla::preces

namespace ROOT {
   // Wrapper around operator delete
   static void delete_slacLcLeuler(void *p) {
      delete ((::sla::euler*)p);
   }
   static void deleteArray_slacLcLeuler(void *p) {
      delete [] ((::sla::euler*)p);
   }
   static void destruct_slacLcLeuler(void *p) {
      typedef ::sla::euler current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::sla::euler

namespace ROOT {
   // Wrapper around operator delete
   static void delete_slacLcLnutc(void *p) {
      delete ((::sla::nutc*)p);
   }
   static void deleteArray_slacLcLnutc(void *p) {
      delete [] ((::sla::nutc*)p);
   }
   static void destruct_slacLcLnutc(void *p) {
      typedef ::sla::nutc current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::sla::nutc

namespace ROOT {
   // Wrapper around operator delete
   static void delete_slacLcLrefco(void *p) {
      delete ((::sla::refco*)p);
   }
   static void deleteArray_slacLcLrefco(void *p) {
      delete [] ((::sla::refco*)p);
   }
   static void destruct_slacLcLrefco(void *p) {
      typedef ::sla::refco current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::sla::refco

namespace ROOT {
   // Wrapper around operator delete
   static void delete_slacLcLdvn(void *p) {
      delete ((::sla::dvn*)p);
   }
   static void deleteArray_slacLcLdvn(void *p) {
      delete [] ((::sla::dvn*)p);
   }
   static void destruct_slacLcLdvn(void *p) {
      typedef ::sla::dvn current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::sla::dvn

namespace ROOT {
   // Wrapper around operator delete
   static void delete_slacLcLpertel(void *p) {
      delete ((::sla::pertel*)p);
   }
   static void deleteArray_slacLcLpertel(void *p) {
      delete [] ((::sla::pertel*)p);
   }
   static void destruct_slacLcLpertel(void *p) {
      typedef ::sla::pertel current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::sla::pertel

namespace ROOT {
   // Wrapper around operator delete
   static void delete_slacLcLmapqkz(void *p) {
      delete ((::sla::mapqkz*)p);
   }
   static void deleteArray_slacLcLmapqkz(void *p) {
      delete [] ((::sla::mapqkz*)p);
   }
   static void destruct_slacLcLmapqkz(void *p) {
      typedef ::sla::mapqkz current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::sla::mapqkz

namespace ROOT {
   // Wrapper around operator delete
   static void delete_slacLcLmap(void *p) {
      delete ((::sla::map*)p);
   }
   static void deleteArray_slacLcLmap(void *p) {
      delete [] ((::sla::map*)p);
   }
   static void destruct_slacLcLmap(void *p) {
      typedef ::sla::map current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::sla::map

namespace ROOT {
   // Wrapper around operator delete
   static void delete_slacLcLaoppa(void *p) {
      delete ((::sla::aoppa*)p);
   }
   static void deleteArray_slacLcLaoppa(void *p) {
      delete [] ((::sla::aoppa*)p);
   }
   static void destruct_slacLcLaoppa(void *p) {
      typedef ::sla::aoppa current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::sla::aoppa

namespace ROOT {
   // Wrapper around operator delete
   static void delete_slacLcLpolmo(void *p) {
      delete ((::sla::polmo*)p);
   }
   static void deleteArray_slacLcLpolmo(void *p) {
      delete [] ((::sla::polmo*)p);
   }
   static void destruct_slacLcLpolmo(void *p) {
      typedef ::sla::polmo current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::sla::polmo

namespace ROOT {
   // Wrapper around operator delete
   static void delete_slacLcLdmxv(void *p) {
      delete ((::sla::dmxv*)p);
   }
   static void deleteArray_slacLcLdmxv(void *p) {
      delete [] ((::sla::dmxv*)p);
   }
   static void destruct_slacLcLdmxv(void *p) {
      typedef ::sla::dmxv current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::sla::dmxv

namespace ROOT {
   // Wrapper around operator delete
   static void delete_slacLcLdeuler(void *p) {
      delete ((::sla::deuler*)p);
   }
   static void deleteArray_slacLcLdeuler(void *p) {
      delete [] ((::sla::deuler*)p);
   }
   static void destruct_slacLcLdeuler(void *p) {
      typedef ::sla::deuler current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::sla::deuler

namespace ROOT {
   // Wrapper around operator delete
   static void delete_slacLcLcs2c(void *p) {
      delete ((::sla::cs2c*)p);
   }
   static void deleteArray_slacLcLcs2c(void *p) {
      delete [] ((::sla::cs2c*)p);
   }
   static void destruct_slacLcLcs2c(void *p) {
      typedef ::sla::cs2c current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::sla::cs2c

namespace ROOT {
   // Wrapper around operator delete
   static void delete_slacLcLimxv(void *p) {
      delete ((::sla::imxv*)p);
   }
   static void deleteArray_slacLcLimxv(void *p) {
      delete [] ((::sla::imxv*)p);
   }
   static void destruct_slacLcLimxv(void *p) {
      typedef ::sla::imxv current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::sla::imxv

namespace ROOT {
   // Wrapper around operator delete
   static void delete_slacLcLfk5hz(void *p) {
      delete ((::sla::fk5hz*)p);
   }
   static void deleteArray_slacLcLfk5hz(void *p) {
      delete [] ((::sla::fk5hz*)p);
   }
   static void destruct_slacLcLfk5hz(void *p) {
      typedef ::sla::fk5hz current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::sla::fk5hz

namespace ROOT {
   // Wrapper around operator delete
   static void delete_slacLcLdcc2s(void *p) {
      delete ((::sla::dcc2s*)p);
   }
   static void deleteArray_slacLcLdcc2s(void *p) {
      delete [] ((::sla::dcc2s*)p);
   }
   static void destruct_slacLcLdcc2s(void *p) {
      typedef ::sla::dcc2s current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::sla::dcc2s

namespace ROOT {
   // Wrapper around operator delete
   static void delete_slacLcLrefro(void *p) {
      delete ((::sla::refro*)p);
   }
   static void deleteArray_slacLcLrefro(void *p) {
      delete [] ((::sla::refro*)p);
   }
   static void destruct_slacLcLrefro(void *p) {
      typedef ::sla::refro current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::sla::refro

namespace ROOT {
   // Wrapper around operator delete
   static void delete_slacLcLav2m(void *p) {
      delete ((::sla::av2m*)p);
   }
   static void deleteArray_slacLcLav2m(void *p) {
      delete [] ((::sla::av2m*)p);
   }
   static void destruct_slacLcLav2m(void *p) {
      typedef ::sla::av2m current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::sla::av2m

namespace ROOT {
   // Wrapper around operator delete
   static void delete_slacLcLel2ue(void *p) {
      delete ((::sla::el2ue*)p);
   }
   static void deleteArray_slacLcLel2ue(void *p) {
      delete [] ((::sla::el2ue*)p);
   }
   static void destruct_slacLcLel2ue(void *p) {
      typedef ::sla::el2ue current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::sla::el2ue

namespace ROOT {
   // Wrapper around operator delete
   static void delete_slacLcLcr2af(void *p) {
      delete ((::sla::cr2af*)p);
   }
   static void deleteArray_slacLcLcr2af(void *p) {
      delete [] ((::sla::cr2af*)p);
   }
   static void destruct_slacLcLcr2af(void *p) {
      typedef ::sla::cr2af current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::sla::cr2af

namespace ROOT {
   // Wrapper around operator delete
   static void delete_slacLcLecleq(void *p) {
      delete ((::sla::ecleq*)p);
   }
   static void deleteArray_slacLcLecleq(void *p) {
      delete [] ((::sla::ecleq*)p);
   }
   static void destruct_slacLcLecleq(void *p) {
      typedef ::sla::ecleq current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::sla::ecleq

namespace ROOT {
   // Wrapper around operator delete
   static void delete_slacLcLmappa(void *p) {
      delete ((::sla::mappa*)p);
   }
   static void deleteArray_slacLcLmappa(void *p) {
      delete [] ((::sla::mappa*)p);
   }
   static void destruct_slacLcLmappa(void *p) {
      typedef ::sla::mappa current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::sla::mappa

namespace ROOT {
   // Wrapper around operator delete
   static void delete_slacLcLctf2d(void *p) {
      delete ((::sla::ctf2d*)p);
   }
   static void deleteArray_slacLcLctf2d(void *p) {
      delete [] ((::sla::ctf2d*)p);
   }
   static void destruct_slacLcLctf2d(void *p) {
      typedef ::sla::ctf2d current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::sla::ctf2d

namespace ROOT {
   // Wrapper around operator delete
   static void delete_slacLcLunpcd(void *p) {
      delete ((::sla::unpcd*)p);
   }
   static void deleteArray_slacLcLunpcd(void *p) {
      delete [] ((::sla::unpcd*)p);
   }
   static void destruct_slacLcLunpcd(void *p) {
      typedef ::sla::unpcd current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::sla::unpcd

namespace ROOT {
   // Wrapper around operator delete
   static void delete_slacLcLcd2tf(void *p) {
      delete ((::sla::cd2tf*)p);
   }
   static void deleteArray_slacLcLcd2tf(void *p) {
      delete [] ((::sla::cd2tf*)p);
   }
   static void destruct_slacLcLcd2tf(void *p) {
      typedef ::sla::cd2tf current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::sla::cd2tf

namespace ROOT {
   // Wrapper around operator delete
   static void delete_slacLcLmxm(void *p) {
      delete ((::sla::mxm*)p);
   }
   static void deleteArray_slacLcLmxm(void *p) {
      delete [] ((::sla::mxm*)p);
   }
   static void destruct_slacLcLmxm(void *p) {
      typedef ::sla::mxm current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::sla::mxm

namespace ROOT {
   // Wrapper around operator delete
   static void delete_slacLcLdfltin(void *p) {
      delete ((::sla::dfltin*)p);
   }
   static void deleteArray_slacLcLdfltin(void *p) {
      delete [] ((::sla::dfltin*)p);
   }
   static void destruct_slacLcLdfltin(void *p) {
      typedef ::sla::dfltin current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::sla::dfltin

namespace ROOT {
   // Wrapper around operator delete
   static void delete_slacLcLplantu(void *p) {
      delete ((::sla::plantu*)p);
   }
   static void deleteArray_slacLcLplantu(void *p) {
      delete [] ((::sla::plantu*)p);
   }
   static void destruct_slacLcLplantu(void *p) {
      typedef ::sla::plantu current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::sla::plantu

namespace ROOT {
   // Wrapper around operator delete
   static void delete_slacLcLdvxv(void *p) {
      delete ((::sla::dvxv*)p);
   }
   static void deleteArray_slacLcLdvxv(void *p) {
      delete [] ((::sla::dvxv*)p);
   }
   static void destruct_slacLcLdvxv(void *p) {
      typedef ::sla::dvxv current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::sla::dvxv

namespace ROOT {
   // Wrapper around operator delete
   static void delete_slacLcLaltaz(void *p) {
      delete ((::sla::altaz*)p);
   }
   static void deleteArray_slacLcLaltaz(void *p) {
      delete [] ((::sla::altaz*)p);
   }
   static void destruct_slacLcLaltaz(void *p) {
      typedef ::sla::altaz current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::sla::altaz

namespace ROOT {
   // Wrapper around operator delete
   static void delete_slacLcLdav2m(void *p) {
      delete ((::sla::dav2m*)p);
   }
   static void deleteArray_slacLcLdav2m(void *p) {
      delete [] ((::sla::dav2m*)p);
   }
   static void destruct_slacLcLdav2m(void *p) {
      typedef ::sla::dav2m current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::sla::dav2m

namespace ROOT {
   // Wrapper around operator delete
   static void delete_slacLcLde2h(void *p) {
      delete ((::sla::de2h*)p);
   }
   static void deleteArray_slacLcLde2h(void *p) {
      delete [] ((::sla::de2h*)p);
   }
   static void destruct_slacLcLde2h(void *p) {
      typedef ::sla::de2h current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::sla::de2h

namespace ROOT {
   // Wrapper around operator delete
   static void delete_slacLcLmoon(void *p) {
      delete ((::sla::moon*)p);
   }
   static void deleteArray_slacLcLmoon(void *p) {
      delete [] ((::sla::moon*)p);
   }
   static void destruct_slacLcLmoon(void *p) {
      typedef ::sla::moon current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::sla::moon

namespace ROOT {
   // Wrapper around operator delete
   static void delete_slacLcLdd2tf(void *p) {
      delete ((::sla::dd2tf*)p);
   }
   static void deleteArray_slacLcLdd2tf(void *p) {
      delete [] ((::sla::dd2tf*)p);
   }
   static void destruct_slacLcLdd2tf(void *p) {
      typedef ::sla::dd2tf current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::sla::dd2tf

namespace ROOT {
   // Wrapper around operator delete
   static void delete_slacLcLgaleq(void *p) {
      delete ((::sla::galeq*)p);
   }
   static void deleteArray_slacLcLgaleq(void *p) {
      delete [] ((::sla::galeq*)p);
   }
   static void destruct_slacLcLgaleq(void *p) {
      typedef ::sla::galeq current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::sla::galeq

namespace ROOT {
   // Wrapper around operator delete
   static void delete_slacLcLoap(void *p) {
      delete ((::sla::oap*)p);
   }
   static void deleteArray_slacLcLoap(void *p) {
      delete [] ((::sla::oap*)p);
   }
   static void destruct_slacLcLoap(void *p) {
      typedef ::sla::oap current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::sla::oap

namespace ROOT {
   // Wrapper around operator delete
   static void delete_slacLcLnutc80(void *p) {
      delete ((::sla::nutc80*)p);
   }
   static void deleteArray_slacLcLnutc80(void *p) {
      delete [] ((::sla::nutc80*)p);
   }
   static void destruct_slacLcLnutc80(void *p) {
      typedef ::sla::nutc80 current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::sla::nutc80

namespace ROOT {
   // Wrapper around operator delete
   static void delete_slacLcLplanel(void *p) {
      delete ((::sla::planel*)p);
   }
   static void deleteArray_slacLcLplanel(void *p) {
      delete [] ((::sla::planel*)p);
   }
   static void destruct_slacLcLplanel(void *p) {
      typedef ::sla::planel current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::sla::planel

namespace ROOT {
   // Wrapper around operator delete
   static void delete_slacLcLh2fk5(void *p) {
      delete ((::sla::h2fk5*)p);
   }
   static void deleteArray_slacLcLh2fk5(void *p) {
      delete [] ((::sla::h2fk5*)p);
   }
   static void destruct_slacLcLh2fk5(void *p) {
      typedef ::sla::h2fk5 current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::sla::h2fk5

namespace ROOT {
   // Wrapper around operator delete
   static void delete_slacLcLdmxm(void *p) {
      delete ((::sla::dmxm*)p);
   }
   static void deleteArray_slacLcLdmxm(void *p) {
      delete [] ((::sla::dmxm*)p);
   }
   static void destruct_slacLcLdmxm(void *p) {
      typedef ::sla::dmxm current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::sla::dmxm

namespace ROOT {
   // Wrapper around operator delete
   static void delete_slacLcLvn(void *p) {
      delete ((::sla::vn*)p);
   }
   static void deleteArray_slacLcLvn(void *p) {
      delete [] ((::sla::vn*)p);
   }
   static void destruct_slacLcLvn(void *p) {
      typedef ::sla::vn current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::sla::vn

namespace ROOT {
   // Wrapper around operator delete
   static void delete_slacLcLclyd(void *p) {
      delete ((::sla::clyd*)p);
   }
   static void deleteArray_slacLcLclyd(void *p) {
      delete [] ((::sla::clyd*)p);
   }
   static void destruct_slacLcLclyd(void *p) {
      typedef ::sla::clyd current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::sla::clyd

namespace ROOT {
   // Wrapper around operator delete
   static void delete_slacLcLm2av(void *p) {
      delete ((::sla::m2av*)p);
   }
   static void deleteArray_slacLcLm2av(void *p) {
      delete [] ((::sla::m2av*)p);
   }
   static void destruct_slacLcLm2av(void *p) {
      typedef ::sla::m2av current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::sla::m2av

namespace ROOT {
   // Wrapper around operator delete
   static void delete_slacLcLdr2tf(void *p) {
      delete ((::sla::dr2tf*)p);
   }
   static void deleteArray_slacLcLdr2tf(void *p) {
      delete [] ((::sla::dr2tf*)p);
   }
   static void destruct_slacLcLdr2tf(void *p) {
      typedef ::sla::dr2tf current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::sla::dr2tf

namespace ROOT {
   // Wrapper around operator delete
   static void delete_slacLcL_atms(void *p) {
      delete ((::sla::_atms*)p);
   }
   static void deleteArray_slacLcL_atms(void *p) {
      delete [] ((::sla::_atms*)p);
   }
   static void destruct_slacLcL_atms(void *p) {
      typedef ::sla::_atms current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::sla::_atms

namespace ROOT {
   // Wrapper around operator delete
   static void delete_slacLcLdcmpf(void *p) {
      delete ((::sla::dcmpf*)p);
   }
   static void deleteArray_slacLcLdcmpf(void *p) {
      delete [] ((::sla::dcmpf*)p);
   }
   static void destruct_slacLcLdcmpf(void *p) {
      typedef ::sla::dcmpf current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::sla::dcmpf

namespace ROOT {
   // Wrapper around operator delete
   static void delete_slacLcLafin(void *p) {
      delete ((::sla::afin*)p);
   }
   static void deleteArray_slacLcLafin(void *p) {
      delete [] ((::sla::afin*)p);
   }
   static void destruct_slacLcLafin(void *p) {
      typedef ::sla::afin current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::sla::afin

namespace ROOT {
   // Wrapper around operator delete
   static void delete_slacLcLds2tp(void *p) {
      delete ((::sla::ds2tp*)p);
   }
   static void deleteArray_slacLcLds2tp(void *p) {
      delete [] ((::sla::ds2tp*)p);
   }
   static void destruct_slacLcLds2tp(void *p) {
      typedef ::sla::ds2tp current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::sla::ds2tp

namespace ROOT {
   // Wrapper around operator delete
   static void delete_slacLcLdtp2s(void *p) {
      delete ((::sla::dtp2s*)p);
   }
   static void deleteArray_slacLcLdtp2s(void *p) {
      delete [] ((::sla::dtp2s*)p);
   }
   static void destruct_slacLcLdtp2s(void *p) {
      typedef ::sla::dtp2s current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::sla::dtp2s

namespace ROOT {
   // Wrapper around operator delete
   static void delete_slacLcLfk52h(void *p) {
      delete ((::sla::fk52h*)p);
   }
   static void deleteArray_slacLcLfk52h(void *p) {
      delete [] ((::sla::fk52h*)p);
   }
   static void destruct_slacLcLfk52h(void *p) {
      typedef ::sla::fk52h current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::sla::fk52h

namespace ROOT {
   // Wrapper around operator delete
   static void delete_slacLcLmapqk(void *p) {
      delete ((::sla::mapqk*)p);
   }
   static void deleteArray_slacLcLmapqk(void *p) {
      delete [] ((::sla::mapqk*)p);
   }
   static void destruct_slacLcLmapqk(void *p) {
      typedef ::sla::mapqk current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::sla::mapqk

namespace ROOT {
   // Wrapper around operator delete
   static void delete_slacLcLctf2r(void *p) {
      delete ((::sla::ctf2r*)p);
   }
   static void deleteArray_slacLcLctf2r(void *p) {
      delete [] ((::sla::ctf2r*)p);
   }
   static void destruct_slacLcLctf2r(void *p) {
      typedef ::sla::ctf2r current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::sla::ctf2r

namespace ROOT {
   // Wrapper around operator delete
   static void delete_slacLcLpertue(void *p) {
      delete ((::sla::pertue*)p);
   }
   static void deleteArray_slacLcLpertue(void *p) {
      delete [] ((::sla::pertue*)p);
   }
   static void destruct_slacLcLpertue(void *p) {
      typedef ::sla::pertue current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::sla::pertue

namespace ROOT {
   // Wrapper around operator delete
   static void delete_slacLcLatmdsp(void *p) {
      delete ((::sla::atmdsp*)p);
   }
   static void deleteArray_slacLcLatmdsp(void *p) {
      delete [] ((::sla::atmdsp*)p);
   }
   static void destruct_slacLcLatmdsp(void *p) {
      typedef ::sla::atmdsp current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::sla::atmdsp

namespace ROOT {
   // Wrapper around operator delete
   static void delete_slacLcLprebn(void *p) {
      delete ((::sla::prebn*)p);
   }
   static void deleteArray_slacLcLprebn(void *p) {
      delete [] ((::sla::prebn*)p);
   }
   static void destruct_slacLcLprebn(void *p) {
      typedef ::sla::prebn current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::sla::prebn

namespace ROOT {
   // Wrapper around operator delete
   static void delete_slacLcLh2e(void *p) {
      delete ((::sla::h2e*)p);
   }
   static void deleteArray_slacLcLh2e(void *p) {
      delete [] ((::sla::h2e*)p);
   }
   static void destruct_slacLcLh2e(void *p) {
      typedef ::sla::h2e current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::sla::h2e

namespace ROOT {
   // Wrapper around operator delete
   static void delete_slacLcLue2el(void *p) {
      delete ((::sla::ue2el*)p);
   }
   static void deleteArray_slacLcLue2el(void *p) {
      delete [] ((::sla::ue2el*)p);
   }
   static void destruct_slacLcLue2el(void *p) {
      typedef ::sla::ue2el current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::sla::ue2el

namespace ROOT {
   // Wrapper around operator delete
   static void delete_slacLcLeg50(void *p) {
      delete ((::sla::eg50*)p);
   }
   static void deleteArray_slacLcLeg50(void *p) {
      delete [] ((::sla::eg50*)p);
   }
   static void destruct_slacLcLeg50(void *p) {
      typedef ::sla::eg50 current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::sla::eg50

namespace ROOT {
   // Wrapper around operator delete
   static void delete_slacLcLinvf(void *p) {
      delete ((::sla::invf*)p);
   }
   static void deleteArray_slacLcLinvf(void *p) {
      delete [] ((::sla::invf*)p);
   }
   static void destruct_slacLcLinvf(void *p) {
      typedef ::sla::invf current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::sla::invf

namespace ROOT {
   // Wrapper around operator delete
   static void delete_slacLcLfk45z(void *p) {
      delete ((::sla::fk45z*)p);
   }
   static void deleteArray_slacLcLfk45z(void *p) {
      delete [] ((::sla::fk45z*)p);
   }
   static void destruct_slacLcLfk45z(void *p) {
      typedef ::sla::fk45z current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::sla::fk45z

namespace ROOT {
   // Wrapper around operator delete
   static void delete_slacLcLdimxv(void *p) {
      delete ((::sla::dimxv*)p);
   }
   static void deleteArray_slacLcLdimxv(void *p) {
      delete [] ((::sla::dimxv*)p);
   }
   static void destruct_slacLcLdimxv(void *p) {
      typedef ::sla::dimxv current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::sla::dimxv

namespace ROOT {
   // Wrapper around operator delete
   static void delete_slacLcLdaf2r(void *p) {
      delete ((::sla::daf2r*)p);
   }
   static void deleteArray_slacLcLdaf2r(void *p) {
      delete [] ((::sla::daf2r*)p);
   }
   static void destruct_slacLcLdaf2r(void *p) {
      typedef ::sla::daf2r current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::sla::daf2r

namespace ROOT {
   // Wrapper around operator delete
   static void delete_slacLcLpdq2h(void *p) {
      delete ((::sla::pdq2h*)p);
   }
   static void deleteArray_slacLcLpdq2h(void *p) {
      delete [] ((::sla::pdq2h*)p);
   }
   static void destruct_slacLcLpdq2h(void *p) {
      typedef ::sla::pdq2h current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::sla::pdq2h

namespace ROOT {
   // Wrapper around operator delete
   static void delete_slacLcLdh2e(void *p) {
      delete ((::sla::dh2e*)p);
   }
   static void deleteArray_slacLcLdh2e(void *p) {
      delete [] ((::sla::dh2e*)p);
   }
   static void destruct_slacLcLdh2e(void *p) {
      typedef ::sla::dh2e current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::sla::dh2e

namespace ROOT {
   // Wrapper around operator delete
   static void delete_slacLcLdtps2c(void *p) {
      delete ((::sla::dtps2c*)p);
   }
   static void deleteArray_slacLcLdtps2c(void *p) {
      delete [] ((::sla::dtps2c*)p);
   }
   static void destruct_slacLcLdtps2c(void *p) {
      typedef ::sla::dtps2c current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::sla::dtps2c

namespace ROOT {
   // Wrapper around operator delete
   static void delete_slacLcLdm2av(void *p) {
      delete ((::sla::dm2av*)p);
   }
   static void deleteArray_slacLcLdm2av(void *p) {
      delete [] ((::sla::dm2av*)p);
   }
   static void destruct_slacLcLdm2av(void *p) {
      typedef ::sla::dm2av current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::sla::dm2av

namespace ROOT {
   // Wrapper around operator delete
   static void delete_slacLcLprec(void *p) {
      delete ((::sla::prec*)p);
   }
   static void deleteArray_slacLcLprec(void *p) {
      delete [] ((::sla::prec*)p);
   }
   static void destruct_slacLcLprec(void *p) {
      typedef ::sla::prec current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::sla::prec

namespace ROOT {
   // Wrapper around operator delete
   static void delete_slacLcLplante(void *p) {
      delete ((::sla::plante*)p);
   }
   static void deleteArray_slacLcLplante(void *p) {
      delete [] ((::sla::plante*)p);
   }
   static void destruct_slacLcLplante(void *p) {
      typedef ::sla::plante current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::sla::plante

namespace ROOT {
   // Wrapper around operator delete
   static void delete_slacLcLprecl(void *p) {
      delete ((::sla::precl*)p);
   }
   static void deleteArray_slacLcLprecl(void *p) {
      delete [] ((::sla::precl*)p);
   }
   static void destruct_slacLcLprecl(void *p) {
      typedef ::sla::precl current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::sla::precl

namespace ROOT {
   // Wrapper around operator delete
   static void delete_slacLcLkbj(void *p) {
      delete ((::sla::kbj*)p);
   }
   static void deleteArray_slacLcLkbj(void *p) {
      delete [] ((::sla::kbj*)p);
   }
   static void destruct_slacLcLkbj(void *p) {
      typedef ::sla::kbj current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::sla::kbj

namespace ROOT {
   // Wrapper around operator delete
   static void delete_slacLcLpv2ue(void *p) {
      delete ((::sla::pv2ue*)p);
   }
   static void deleteArray_slacLcLpv2ue(void *p) {
      delete [] ((::sla::pv2ue*)p);
   }
   static void destruct_slacLcLpv2ue(void *p) {
      typedef ::sla::pv2ue current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::sla::pv2ue

namespace ROOT {
   // Wrapper around operator delete
   static void delete_slacLcLdcs2c(void *p) {
      delete ((::sla::dcs2c*)p);
   }
   static void deleteArray_slacLcLdcs2c(void *p) {
      delete [] ((::sla::dcs2c*)p);
   }
   static void destruct_slacLcLdcs2c(void *p) {
      typedef ::sla::dcs2c current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::sla::dcs2c

namespace ROOT {
   // Wrapper around operator delete
   static void delete_slacLcLfk54z(void *p) {
      delete ((::sla::fk54z*)p);
   }
   static void deleteArray_slacLcLfk54z(void *p) {
      delete [] ((::sla::fk54z*)p);
   }
   static void destruct_slacLcLfk54z(void *p) {
      typedef ::sla::fk54z current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::sla::fk54z

namespace ROOT {
   // Wrapper around operator delete
   static void delete_slacLcL_idchf(void *p) {
      delete ((::sla::_idchf*)p);
   }
   static void deleteArray_slacLcL_idchf(void *p) {
      delete [] ((::sla::_idchf*)p);
   }
   static void destruct_slacLcL_idchf(void *p) {
      typedef ::sla::_idchf current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::sla::_idchf

namespace ROOT {
   // Wrapper around operator delete
   static void delete_slacLcLdjcl(void *p) {
      delete ((::sla::djcl*)p);
   }
   static void deleteArray_slacLcLdjcl(void *p) {
      delete [] ((::sla::djcl*)p);
   }
   static void destruct_slacLcLdjcl(void *p) {
      typedef ::sla::djcl current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::sla::djcl

namespace ROOT {
   // Wrapper around operator delete
   static void delete_slacLcLdc62s(void *p) {
      delete ((::sla::dc62s*)p);
   }
   static void deleteArray_slacLcLdc62s(void *p) {
      delete [] ((::sla::dc62s*)p);
   }
   static void destruct_slacLcLdc62s(void *p) {
      typedef ::sla::dc62s current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::sla::dc62s

namespace ROOT {
   // Wrapper around operator delete
   static void delete_slacLcLeqgal(void *p) {
      delete ((::sla::eqgal*)p);
   }
   static void deleteArray_slacLcLeqgal(void *p) {
      delete [] ((::sla::eqgal*)p);
   }
   static void destruct_slacLcLeqgal(void *p) {
      typedef ::sla::eqgal current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::sla::eqgal

namespace ROOT {
   // Wrapper around operator delete
   static void delete_slacLcLge50(void *p) {
      delete ((::sla::ge50*)p);
   }
   static void deleteArray_slacLcLge50(void *p) {
      delete [] ((::sla::ge50*)p);
   }
   static void destruct_slacLcLge50(void *p) {
      typedef ::sla::ge50 current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::sla::ge50

namespace ROOT {
   // Wrapper around operator delete
   static void delete_slacLcLcs2c6(void *p) {
      delete ((::sla::cs2c6*)p);
   }
   static void deleteArray_slacLcLcs2c6(void *p) {
      delete [] ((::sla::cs2c6*)p);
   }
   static void destruct_slacLcLcs2c6(void *p) {
      typedef ::sla::cs2c6 current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::sla::cs2c6

namespace ROOT {
   // Wrapper around operator delete
   static void delete_slacLcLs2tp(void *p) {
      delete ((::sla::s2tp*)p);
   }
   static void deleteArray_slacLcLs2tp(void *p) {
      delete [] ((::sla::s2tp*)p);
   }
   static void destruct_slacLcLs2tp(void *p) {
      typedef ::sla::s2tp current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::sla::s2tp

namespace ROOT {
   // Wrapper around operator delete
   static void delete_slacLcLcc2s(void *p) {
      delete ((::sla::cc2s*)p);
   }
   static void deleteArray_slacLcLcc2s(void *p) {
      delete [] ((::sla::cc2s*)p);
   }
   static void destruct_slacLcLcc2s(void *p) {
      typedef ::sla::cc2s current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::sla::cc2s

namespace ROOT {
   // Wrapper around operator delete
   static void delete_slacLcLnut(void *p) {
      delete ((::sla::nut*)p);
   }
   static void deleteArray_slacLcLnut(void *p) {
      delete [] ((::sla::nut*)p);
   }
   static void destruct_slacLcLnut(void *p) {
      typedef ::sla::nut current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::sla::nut

namespace ROOT {
   // Wrapper around operator delete
   static void delete_slacLcLv2tp(void *p) {
      delete ((::sla::v2tp*)p);
   }
   static void deleteArray_slacLcLv2tp(void *p) {
      delete [] ((::sla::v2tp*)p);
   }
   static void destruct_slacLcLv2tp(void *p) {
      typedef ::sla::v2tp current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::sla::v2tp

namespace ROOT {
   // Wrapper around operator delete
   static void delete_slacLcLdjcal(void *p) {
      delete ((::sla::djcal*)p);
   }
   static void deleteArray_slacLcLdjcal(void *p) {
      delete [] ((::sla::djcal*)p);
   }
   static void destruct_slacLcLdjcal(void *p) {
      typedef ::sla::djcal current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::sla::djcal

namespace ROOT {
   // Wrapper around operator delete
   static void delete_slacLcLdtpv2c(void *p) {
      delete ((::sla::dtpv2c*)p);
   }
   static void deleteArray_slacLcLdtpv2c(void *p) {
      delete [] ((::sla::dtpv2c*)p);
   }
   static void destruct_slacLcLdtpv2c(void *p) {
      typedef ::sla::dtpv2c current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::sla::dtpv2c

namespace ROOT {
   // Wrapper around operator delete
   static void delete_slacLcL_idchi(void *p) {
      delete ((::sla::_idchi*)p);
   }
   static void deleteArray_slacLcL_idchi(void *p) {
      delete [] ((::sla::_idchi*)p);
   }
   static void destruct_slacLcL_idchi(void *p) {
      typedef ::sla::_idchi current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::sla::_idchi

namespace ROOT {
   // Wrapper around operator delete
   static void delete_slacLcLds2c6(void *p) {
      delete ((::sla::ds2c6*)p);
   }
   static void deleteArray_slacLcLds2c6(void *p) {
      delete [] ((::sla::ds2c6*)p);
   }
   static void destruct_slacLcLds2c6(void *p) {
      typedef ::sla::ds2c6 current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::sla::ds2c6

namespace ROOT {
   // Wrapper around operator delete
   static void delete_slacLcLetrms(void *p) {
      delete ((::sla::etrms*)p);
   }
   static void deleteArray_slacLcLetrms(void *p) {
      delete [] ((::sla::etrms*)p);
   }
   static void destruct_slacLcLetrms(void *p) {
      typedef ::sla::etrms current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::sla::etrms

namespace ROOT {
   // Wrapper around operator delete
   static void delete_slacLcLrefcoq(void *p) {
      delete ((::sla::refcoq*)p);
   }
   static void deleteArray_slacLcLrefcoq(void *p) {
      delete [] ((::sla::refcoq*)p);
   }
   static void destruct_slacLcLrefcoq(void *p) {
      typedef ::sla::refcoq current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::sla::refcoq

namespace ROOT {
   // Wrapper around operator delete
   static void delete_slacLcLeqecl(void *p) {
      delete ((::sla::eqecl*)p);
   }
   static void deleteArray_slacLcLeqecl(void *p) {
      delete [] ((::sla::eqecl*)p);
   }
   static void destruct_slacLcLeqecl(void *p) {
      typedef ::sla::eqecl current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::sla::eqecl

namespace ROOT {
   // Wrapper around operator delete
   static void delete_slacLcLtps2c(void *p) {
      delete ((::sla::tps2c*)p);
   }
   static void deleteArray_slacLcLtps2c(void *p) {
      delete [] ((::sla::tps2c*)p);
   }
   static void destruct_slacLcLtps2c(void *p) {
      typedef ::sla::tps2c current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::sla::tps2c

namespace ROOT {
   // Wrapper around operator delete
   static void delete_slacLcLfk425(void *p) {
      delete ((::sla::fk425*)p);
   }
   static void deleteArray_slacLcLfk425(void *p) {
      delete [] ((::sla::fk425*)p);
   }
   static void destruct_slacLcLfk425(void *p) {
      typedef ::sla::fk425 current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::sla::fk425

namespace ROOT {
   // Wrapper around operator delete
   static void delete_slacLcLdv2tp(void *p) {
      delete ((::sla::dv2tp*)p);
   }
   static void deleteArray_slacLcLdv2tp(void *p) {
      delete [] ((::sla::dv2tp*)p);
   }
   static void destruct_slacLcLdv2tp(void *p) {
      typedef ::sla::dv2tp current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::sla::dv2tp

namespace ROOT {
   // Wrapper around operator delete
   static void delete_slacLcLtp2s(void *p) {
      delete ((::sla::tp2s*)p);
   }
   static void deleteArray_slacLcLtp2s(void *p) {
      delete [] ((::sla::tp2s*)p);
   }
   static void destruct_slacLcLtp2s(void *p) {
      typedef ::sla::tp2s current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::sla::tp2s

namespace ROOT {
   // Wrapper around operator delete
   static void delete_slacLcLdmoon(void *p) {
      delete ((::sla::dmoon*)p);
   }
   static void deleteArray_slacLcLdmoon(void *p) {
      delete [] ((::sla::dmoon*)p);
   }
   static void destruct_slacLcLdmoon(void *p) {
      typedef ::sla::dmoon current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::sla::dmoon

namespace ROOT {
   // Wrapper around operator delete
   static void delete_slacLcLcaf2r(void *p) {
      delete ((::sla::caf2r*)p);
   }
   static void deleteArray_slacLcLcaf2r(void *p) {
      delete [] ((::sla::caf2r*)p);
   }
   static void destruct_slacLcLcaf2r(void *p) {
      typedef ::sla::caf2r current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::sla::caf2r

namespace ROOT {
   // Wrapper around operator delete
   static void delete_slacLcLearth(void *p) {
      delete ((::sla::earth*)p);
   }
   static void deleteArray_slacLcLearth(void *p) {
      delete [] ((::sla::earth*)p);
   }
   static void destruct_slacLcLearth(void *p) {
      typedef ::sla::earth current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::sla::earth

namespace ROOT {
   // Wrapper around operator delete
   static void delete_slacLcLprenut(void *p) {
      delete ((::sla::prenut*)p);
   }
   static void deleteArray_slacLcLprenut(void *p) {
      delete [] ((::sla::prenut*)p);
   }
   static void destruct_slacLcLprenut(void *p) {
      typedef ::sla::prenut current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::sla::prenut

namespace ROOT {
   // Wrapper around operator delete
   static void delete_slacLcLxy2xy(void *p) {
      delete ((::sla::xy2xy*)p);
   }
   static void deleteArray_slacLcLxy2xy(void *p) {
      delete [] ((::sla::xy2xy*)p);
   }
   static void destruct_slacLcLxy2xy(void *p) {
      typedef ::sla::xy2xy current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::sla::xy2xy

namespace ROOT {
   // Wrapper around operator delete
   static void delete_slacLcLue2pv(void *p) {
      delete ((::sla::ue2pv*)p);
   }
   static void deleteArray_slacLcLue2pv(void *p) {
      delete [] ((::sla::ue2pv*)p);
   }
   static void destruct_slacLcLue2pv(void *p) {
      typedef ::sla::ue2pv current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::sla::ue2pv

namespace ROOT {
   // Wrapper around operator delete
   static void delete_slacLcLsupgal(void *p) {
      delete ((::sla::supgal*)p);
   }
   static void deleteArray_slacLcLsupgal(void *p) {
      delete [] ((::sla::supgal*)p);
   }
   static void destruct_slacLcLsupgal(void *p) {
      typedef ::sla::supgal current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::sla::supgal

namespace ROOT {
   // Wrapper around operator delete
   static void delete_slacLcLdr2af(void *p) {
      delete ((::sla::dr2af*)p);
   }
   static void deleteArray_slacLcLdr2af(void *p) {
      delete [] ((::sla::dr2af*)p);
   }
   static void destruct_slacLcLdr2af(void *p) {
      typedef ::sla::dr2af current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::sla::dr2af

namespace ROOT {
   // Wrapper around operator delete
   static void delete_slacLcLaddet(void *p) {
      delete ((::sla::addet*)p);
   }
   static void deleteArray_slacLcLaddet(void *p) {
      delete [] ((::sla::addet*)p);
   }
   static void destruct_slacLcLaddet(void *p) {
      typedef ::sla::addet current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::sla::addet

namespace ROOT {
   // Wrapper around operator delete
   static void delete_slacLcLrefv(void *p) {
      delete ((::sla::refv*)p);
   }
   static void deleteArray_slacLcLrefv(void *p) {
      delete [] ((::sla::refv*)p);
   }
   static void destruct_slacLcLrefv(void *p) {
      typedef ::sla::refv current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::sla::refv

namespace ROOT {
   // Wrapper around operator delete
   static void delete_slacLcL_atmt(void *p) {
      delete ((::sla::_atmt*)p);
   }
   static void deleteArray_slacLcL_atmt(void *p) {
      delete [] ((::sla::_atmt*)p);
   }
   static void destruct_slacLcL_atmt(void *p) {
      typedef ::sla::_atmt current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::sla::_atmt

namespace ROOT {
   // Wrapper around operator delete
   static void delete_slacLcLcc62s(void *p) {
      delete ((::sla::cc62s*)p);
   }
   static void deleteArray_slacLcLcc62s(void *p) {
      delete [] ((::sla::cc62s*)p);
   }
   static void destruct_slacLcLcc62s(void *p) {
      typedef ::sla::cc62s current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::sla::cc62s

namespace ROOT {
   // Wrapper around operator delete
   static void delete_slacLcLsubet(void *p) {
      delete ((::sla::subet*)p);
   }
   static void deleteArray_slacLcLsubet(void *p) {
      delete [] ((::sla::subet*)p);
   }
   static void destruct_slacLcLsubet(void *p) {
      typedef ::sla::subet current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::sla::subet

namespace ROOT {
   // Wrapper around operator delete
   static void delete_slacLcLcldj(void *p) {
      delete ((::sla::cldj*)p);
   }
   static void deleteArray_slacLcLcldj(void *p) {
      delete [] ((::sla::cldj*)p);
   }
   static void destruct_slacLcLcldj(void *p) {
      typedef ::sla::cldj current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::sla::cldj

namespace ROOT {
   // Wrapper around operator delete
   static void delete_slacLcLdtf2r(void *p) {
      delete ((::sla::dtf2r*)p);
   }
   static void deleteArray_slacLcLdtf2r(void *p) {
      delete [] ((::sla::dtf2r*)p);
   }
   static void destruct_slacLcLdtf2r(void *p) {
      typedef ::sla::dtf2r current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::sla::dtf2r

namespace ROOT {
   // Wrapper around operator delete
   static void delete_slacLcLaop(void *p) {
      delete ((::sla::aop*)p);
   }
   static void deleteArray_slacLcLaop(void *p) {
      delete [] ((::sla::aop*)p);
   }
   static void destruct_slacLcLaop(void *p) {
      typedef ::sla::aop current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::sla::aop

namespace ROOT {
   // Wrapper around operator delete
   static void delete_slacLcLrdplan(void *p) {
      delete ((::sla::rdplan*)p);
   }
   static void deleteArray_slacLcLrdplan(void *p) {
      delete [] ((::sla::rdplan*)p);
   }
   static void destruct_slacLcLrdplan(void *p) {
      typedef ::sla::rdplan current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::sla::rdplan

namespace ROOT {
   // Wrapper around operator delete
   static void delete_slacLcLdbjin(void *p) {
      delete ((::sla::dbjin*)p);
   }
   static void deleteArray_slacLcLdbjin(void *p) {
      delete [] ((::sla::dbjin*)p);
   }
   static void destruct_slacLcLdbjin(void *p) {
      typedef ::sla::dbjin current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::sla::dbjin

namespace ROOT {
   // Wrapper around operator delete
   static void delete_slacLcLtpv2c(void *p) {
      delete ((::sla::tpv2c*)p);
   }
   static void deleteArray_slacLcLtpv2c(void *p) {
      delete [] ((::sla::tpv2c*)p);
   }
   static void destruct_slacLcLtpv2c(void *p) {
      typedef ::sla::tpv2c current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::sla::tpv2c

namespace ROOT {
   // Wrapper around operator delete
   static void delete_slacLcLoapqk(void *p) {
      delete ((::sla::oapqk*)p);
   }
   static void deleteArray_slacLcLoapqk(void *p) {
      delete [] ((::sla::oapqk*)p);
   }
   static void destruct_slacLcLoapqk(void *p) {
      typedef ::sla::oapqk current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::sla::oapqk

namespace ROOT {
   // Wrapper around operator delete
   static void delete_slacLcLpda2h(void *p) {
      delete ((::sla::pda2h*)p);
   }
   static void deleteArray_slacLcLpda2h(void *p) {
      delete [] ((::sla::pda2h*)p);
   }
   static void destruct_slacLcLpda2h(void *p) {
      typedef ::sla::pda2h current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::sla::pda2h

namespace ROOT {
   // Wrapper around operator delete
   static void delete_slacLcLaopqk(void *p) {
      delete ((::sla::aopqk*)p);
   }
   static void deleteArray_slacLcLaopqk(void *p) {
      delete [] ((::sla::aopqk*)p);
   }
   static void destruct_slacLcLaopqk(void *p) {
      typedef ::sla::aopqk current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::sla::aopqk

namespace ROOT {
   // Wrapper around operator delete
   static void delete_slacLcLpm(void *p) {
      delete ((::sla::pm*)p);
   }
   static void deleteArray_slacLcLpm(void *p) {
      delete [] ((::sla::pm*)p);
   }
   static void destruct_slacLcLpm(void *p) {
      typedef ::sla::pm current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::sla::pm

namespace ROOT {
   // Wrapper around operator delete
   static void delete_slacLcLintin(void *p) {
      delete ((::sla::intin*)p);
   }
   static void deleteArray_slacLcLintin(void *p) {
      delete [] ((::sla::intin*)p);
   }
   static void destruct_slacLcLintin(void *p) {
      typedef ::sla::intin current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::sla::intin

namespace ROOT {
   // Wrapper around operator delete
   static void delete_slacLcLcr2tf(void *p) {
      delete ((::sla::cr2tf*)p);
   }
   static void deleteArray_slacLcLcr2tf(void *p) {
      delete [] ((::sla::cr2tf*)p);
   }
   static void destruct_slacLcLcr2tf(void *p) {
      typedef ::sla::cr2tf current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::sla::cr2tf

namespace ROOT {
   // Wrapper around operator delete
   static void delete_slacLcLplanet(void *p) {
      delete ((::sla::planet*)p);
   }
   static void deleteArray_slacLcLplanet(void *p) {
      delete [] ((::sla::planet*)p);
   }
   static void destruct_slacLcLplanet(void *p) {
      typedef ::sla::planet current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::sla::planet

namespace ROOT {
   // Wrapper around operator delete
   static void delete_slacLcLvxv(void *p) {
      delete ((::sla::vxv*)p);
   }
   static void deleteArray_slacLcLvxv(void *p) {
      delete [] ((::sla::vxv*)p);
   }
   static void destruct_slacLcLvxv(void *p) {
      typedef ::sla::vxv current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::sla::vxv

namespace ROOT {
   // Wrapper around operator delete
   static void delete_slacLcLpcd(void *p) {
      delete ((::sla::pcd*)p);
   }
   static void deleteArray_slacLcLpcd(void *p) {
      delete [] ((::sla::pcd*)p);
   }
   static void destruct_slacLcLpcd(void *p) {
      typedef ::sla::pcd current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::sla::pcd

namespace ROOT {
   // Wrapper around operator delete
   static void delete_slacLcLecor(void *p) {
      delete ((::sla::ecor*)p);
   }
   static void deleteArray_slacLcLecor(void *p) {
      delete [] ((::sla::ecor*)p);
   }
   static void destruct_slacLcLecor(void *p) {
      typedef ::sla::ecor current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::sla::ecor

namespace ROOT {
   // Wrapper around operator delete
   static void delete_slacLcLflotin(void *p) {
      delete ((::sla::flotin*)p);
   }
   static void deleteArray_slacLcLflotin(void *p) {
      delete [] ((::sla::flotin*)p);
   }
   static void destruct_slacLcLflotin(void *p) {
      typedef ::sla::flotin current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::sla::flotin

namespace ROOT {
   // Wrapper around operator delete
   static void delete_slacLcLdtp2v(void *p) {
      delete ((::sla::dtp2v*)p);
   }
   static void deleteArray_slacLcLdtp2v(void *p) {
      delete [] ((::sla::dtp2v*)p);
   }
   static void destruct_slacLcLdtp2v(void *p) {
      typedef ::sla::dtp2v current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::sla::dtp2v

namespace ROOT {
   // Wrapper around operator delete
   static void delete_slacLcLe2h(void *p) {
      delete ((::sla::e2h*)p);
   }
   static void deleteArray_slacLcLe2h(void *p) {
      delete [] ((::sla::e2h*)p);
   }
   static void destruct_slacLcLe2h(void *p) {
      typedef ::sla::e2h current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::sla::e2h

namespace ROOT {
   // Wrapper around operator delete
   static void delete_slacLcLfk524(void *p) {
      delete ((::sla::fk524*)p);
   }
   static void deleteArray_slacLcLfk524(void *p) {
      delete [] ((::sla::fk524*)p);
   }
   static void destruct_slacLcLfk524(void *p) {
      typedef ::sla::fk524 current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::sla::fk524

namespace {
  void TriggerDictionaryInitialization_sladOdict_Impl() {
    static const char* headers[] = {
"sla.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/astro/",
0
    };
    static const char* fwdDeclCode = R"DICTFWDDCLS(
#line 1 "sladOdict 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;
namespace sla{template <typename T> struct __attribute__((annotate("$clingAutoload$sla.hh")))  _pointable;
}
namespace sla{struct __attribute__((annotate(R"ATTRDUMP(file_name@@@sla.hh)ATTRDUMP"))) __attribute__((annotate(R"ATTRDUMP(pattern@@@*)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$sla.hh")))  pv2el;}
namespace sla{struct __attribute__((annotate(R"ATTRDUMP(file_name@@@sla.hh)ATTRDUMP"))) __attribute__((annotate(R"ATTRDUMP(pattern@@@*)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$sla.hh")))  geoc;}
namespace sla{struct __attribute__((annotate(R"ATTRDUMP(file_name@@@sla.hh)ATTRDUMP"))) __attribute__((annotate(R"ATTRDUMP(pattern@@@*)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$sla.hh")))  ampqk;}
namespace sla{struct __attribute__((annotate(R"ATTRDUMP(file_name@@@sla.hh)ATTRDUMP"))) __attribute__((annotate(R"ATTRDUMP(pattern@@@*)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$sla.hh")))  aoppat;}
namespace sla{struct __attribute__((annotate(R"ATTRDUMP(file_name@@@sla.hh)ATTRDUMP"))) __attribute__((annotate(R"ATTRDUMP(pattern@@@*)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$sla.hh")))  dafin;}
namespace sla{struct __attribute__((annotate(R"ATTRDUMP(file_name@@@sla.hh)ATTRDUMP"))) __attribute__((annotate(R"ATTRDUMP(pattern@@@*)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$sla.hh")))  ecmat;}
namespace sla{struct __attribute__((annotate(R"ATTRDUMP(file_name@@@sla.hh)ATTRDUMP"))) __attribute__((annotate(R"ATTRDUMP(pattern@@@*)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$sla.hh")))  amp;}
namespace sla{struct __attribute__((annotate(R"ATTRDUMP(file_name@@@sla.hh)ATTRDUMP"))) __attribute__((annotate(R"ATTRDUMP(pattern@@@*)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$sla.hh")))  tp2v;}
namespace sla{struct __attribute__((annotate(R"ATTRDUMP(file_name@@@sla.hh)ATTRDUMP"))) __attribute__((annotate(R"ATTRDUMP(pattern@@@*)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$sla.hh")))  refz;}
namespace sla{struct __attribute__((annotate(R"ATTRDUMP(file_name@@@sla.hh)ATTRDUMP"))) __attribute__((annotate(R"ATTRDUMP(pattern@@@*)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$sla.hh")))  caldj;}
namespace sla{struct __attribute__((annotate(R"ATTRDUMP(file_name@@@sla.hh)ATTRDUMP"))) __attribute__((annotate(R"ATTRDUMP(pattern@@@*)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$sla.hh")))  calyd;}
namespace sla{struct __attribute__((annotate(R"ATTRDUMP(file_name@@@sla.hh)ATTRDUMP"))) __attribute__((annotate(R"ATTRDUMP(pattern@@@*)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$sla.hh")))  mxv;}
namespace sla{struct __attribute__((annotate(R"ATTRDUMP(file_name@@@sla.hh)ATTRDUMP"))) __attribute__((annotate(R"ATTRDUMP(pattern@@@*)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$sla.hh")))  epv;}
namespace sla{struct __attribute__((annotate(R"ATTRDUMP(file_name@@@sla.hh)ATTRDUMP"))) __attribute__((annotate(R"ATTRDUMP(pattern@@@*)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$sla.hh")))  dtf2d;}
namespace sla{struct __attribute__((annotate(R"ATTRDUMP(file_name@@@sla.hh)ATTRDUMP"))) __attribute__((annotate(R"ATTRDUMP(pattern@@@*)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$sla.hh")))  galsup;}
namespace sla{struct __attribute__((annotate(R"ATTRDUMP(file_name@@@sla.hh)ATTRDUMP"))) __attribute__((annotate(R"ATTRDUMP(pattern@@@*)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$sla.hh")))  preces;}
namespace sla{struct __attribute__((annotate(R"ATTRDUMP(file_name@@@sla.hh)ATTRDUMP"))) __attribute__((annotate(R"ATTRDUMP(pattern@@@*)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$sla.hh")))  euler;}
namespace sla{struct __attribute__((annotate(R"ATTRDUMP(file_name@@@sla.hh)ATTRDUMP"))) __attribute__((annotate(R"ATTRDUMP(pattern@@@*)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$sla.hh")))  nutc;}
namespace sla{struct __attribute__((annotate(R"ATTRDUMP(file_name@@@sla.hh)ATTRDUMP"))) __attribute__((annotate(R"ATTRDUMP(pattern@@@*)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$sla.hh")))  refco;}
namespace sla{struct __attribute__((annotate(R"ATTRDUMP(file_name@@@sla.hh)ATTRDUMP"))) __attribute__((annotate(R"ATTRDUMP(pattern@@@*)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$sla.hh")))  dvn;}
namespace sla{struct __attribute__((annotate(R"ATTRDUMP(file_name@@@sla.hh)ATTRDUMP"))) __attribute__((annotate(R"ATTRDUMP(pattern@@@*)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$sla.hh")))  pertel;}
namespace sla{struct __attribute__((annotate(R"ATTRDUMP(file_name@@@sla.hh)ATTRDUMP"))) __attribute__((annotate(R"ATTRDUMP(pattern@@@*)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$sla.hh")))  mapqkz;}
namespace sla{struct __attribute__((annotate(R"ATTRDUMP(file_name@@@sla.hh)ATTRDUMP"))) __attribute__((annotate(R"ATTRDUMP(pattern@@@*)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$sla.hh")))  map;}
namespace sla{struct __attribute__((annotate(R"ATTRDUMP(file_name@@@sla.hh)ATTRDUMP"))) __attribute__((annotate(R"ATTRDUMP(pattern@@@*)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$sla.hh")))  aoppa;}
namespace sla{struct __attribute__((annotate(R"ATTRDUMP(file_name@@@sla.hh)ATTRDUMP"))) __attribute__((annotate(R"ATTRDUMP(pattern@@@*)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$sla.hh")))  polmo;}
namespace sla{struct __attribute__((annotate(R"ATTRDUMP(file_name@@@sla.hh)ATTRDUMP"))) __attribute__((annotate(R"ATTRDUMP(pattern@@@*)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$sla.hh")))  dmxv;}
namespace sla{struct __attribute__((annotate(R"ATTRDUMP(file_name@@@sla.hh)ATTRDUMP"))) __attribute__((annotate(R"ATTRDUMP(pattern@@@*)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$sla.hh")))  deuler;}
namespace sla{struct __attribute__((annotate(R"ATTRDUMP(file_name@@@sla.hh)ATTRDUMP"))) __attribute__((annotate(R"ATTRDUMP(pattern@@@*)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$sla.hh")))  cs2c;}
namespace sla{struct __attribute__((annotate(R"ATTRDUMP(file_name@@@sla.hh)ATTRDUMP"))) __attribute__((annotate(R"ATTRDUMP(pattern@@@*)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$sla.hh")))  imxv;}
namespace sla{struct __attribute__((annotate(R"ATTRDUMP(file_name@@@sla.hh)ATTRDUMP"))) __attribute__((annotate(R"ATTRDUMP(pattern@@@*)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$sla.hh")))  fk5hz;}
namespace sla{struct __attribute__((annotate(R"ATTRDUMP(file_name@@@sla.hh)ATTRDUMP"))) __attribute__((annotate(R"ATTRDUMP(pattern@@@*)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$sla.hh")))  dcc2s;}
namespace sla{struct __attribute__((annotate(R"ATTRDUMP(file_name@@@sla.hh)ATTRDUMP"))) __attribute__((annotate(R"ATTRDUMP(pattern@@@*)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$sla.hh")))  refro;}
namespace sla{struct __attribute__((annotate(R"ATTRDUMP(file_name@@@sla.hh)ATTRDUMP"))) __attribute__((annotate(R"ATTRDUMP(pattern@@@*)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$sla.hh")))  av2m;}
namespace sla{struct __attribute__((annotate(R"ATTRDUMP(file_name@@@sla.hh)ATTRDUMP"))) __attribute__((annotate(R"ATTRDUMP(pattern@@@*)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$sla.hh")))  el2ue;}
namespace sla{struct __attribute__((annotate(R"ATTRDUMP(file_name@@@sla.hh)ATTRDUMP"))) __attribute__((annotate(R"ATTRDUMP(pattern@@@*)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$sla.hh")))  cr2af;}
namespace sla{struct __attribute__((annotate(R"ATTRDUMP(file_name@@@sla.hh)ATTRDUMP"))) __attribute__((annotate(R"ATTRDUMP(pattern@@@*)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$sla.hh")))  ecleq;}
namespace sla{struct __attribute__((annotate(R"ATTRDUMP(file_name@@@sla.hh)ATTRDUMP"))) __attribute__((annotate(R"ATTRDUMP(pattern@@@*)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$sla.hh")))  mappa;}
namespace sla{struct __attribute__((annotate(R"ATTRDUMP(file_name@@@sla.hh)ATTRDUMP"))) __attribute__((annotate(R"ATTRDUMP(pattern@@@*)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$sla.hh")))  ctf2d;}
namespace sla{struct __attribute__((annotate(R"ATTRDUMP(file_name@@@sla.hh)ATTRDUMP"))) __attribute__((annotate(R"ATTRDUMP(pattern@@@*)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$sla.hh")))  unpcd;}
namespace sla{struct __attribute__((annotate(R"ATTRDUMP(file_name@@@sla.hh)ATTRDUMP"))) __attribute__((annotate(R"ATTRDUMP(pattern@@@*)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$sla.hh")))  cd2tf;}
namespace sla{struct __attribute__((annotate(R"ATTRDUMP(file_name@@@sla.hh)ATTRDUMP"))) __attribute__((annotate(R"ATTRDUMP(pattern@@@*)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$sla.hh")))  mxm;}
namespace sla{struct __attribute__((annotate(R"ATTRDUMP(file_name@@@sla.hh)ATTRDUMP"))) __attribute__((annotate(R"ATTRDUMP(pattern@@@*)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$sla.hh")))  dfltin;}
namespace sla{struct __attribute__((annotate(R"ATTRDUMP(file_name@@@sla.hh)ATTRDUMP"))) __attribute__((annotate(R"ATTRDUMP(pattern@@@*)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$sla.hh")))  plantu;}
namespace sla{struct __attribute__((annotate(R"ATTRDUMP(file_name@@@sla.hh)ATTRDUMP"))) __attribute__((annotate(R"ATTRDUMP(pattern@@@*)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$sla.hh")))  dvxv;}
namespace sla{struct __attribute__((annotate(R"ATTRDUMP(file_name@@@sla.hh)ATTRDUMP"))) __attribute__((annotate(R"ATTRDUMP(pattern@@@*)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$sla.hh")))  altaz;}
namespace sla{struct __attribute__((annotate(R"ATTRDUMP(file_name@@@sla.hh)ATTRDUMP"))) __attribute__((annotate(R"ATTRDUMP(pattern@@@*)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$sla.hh")))  dav2m;}
namespace sla{struct __attribute__((annotate(R"ATTRDUMP(file_name@@@sla.hh)ATTRDUMP"))) __attribute__((annotate(R"ATTRDUMP(pattern@@@*)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$sla.hh")))  de2h;}
namespace sla{struct __attribute__((annotate(R"ATTRDUMP(file_name@@@sla.hh)ATTRDUMP"))) __attribute__((annotate(R"ATTRDUMP(pattern@@@*)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$sla.hh")))  moon;}
namespace sla{struct __attribute__((annotate(R"ATTRDUMP(file_name@@@sla.hh)ATTRDUMP"))) __attribute__((annotate(R"ATTRDUMP(pattern@@@*)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$sla.hh")))  dd2tf;}
namespace sla{struct __attribute__((annotate(R"ATTRDUMP(file_name@@@sla.hh)ATTRDUMP"))) __attribute__((annotate(R"ATTRDUMP(pattern@@@*)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$sla.hh")))  galeq;}
namespace sla{struct __attribute__((annotate(R"ATTRDUMP(file_name@@@sla.hh)ATTRDUMP"))) __attribute__((annotate(R"ATTRDUMP(pattern@@@*)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$sla.hh")))  oap;}
namespace sla{struct __attribute__((annotate(R"ATTRDUMP(file_name@@@sla.hh)ATTRDUMP"))) __attribute__((annotate(R"ATTRDUMP(pattern@@@*)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$sla.hh")))  nutc80;}
namespace sla{struct __attribute__((annotate(R"ATTRDUMP(file_name@@@sla.hh)ATTRDUMP"))) __attribute__((annotate(R"ATTRDUMP(pattern@@@*)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$sla.hh")))  planel;}
namespace sla{struct __attribute__((annotate(R"ATTRDUMP(file_name@@@sla.hh)ATTRDUMP"))) __attribute__((annotate(R"ATTRDUMP(pattern@@@*)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$sla.hh")))  h2fk5;}
namespace sla{struct __attribute__((annotate(R"ATTRDUMP(file_name@@@sla.hh)ATTRDUMP"))) __attribute__((annotate(R"ATTRDUMP(pattern@@@*)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$sla.hh")))  dmxm;}
namespace sla{struct __attribute__((annotate(R"ATTRDUMP(file_name@@@sla.hh)ATTRDUMP"))) __attribute__((annotate(R"ATTRDUMP(pattern@@@*)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$sla.hh")))  vn;}
namespace sla{struct __attribute__((annotate(R"ATTRDUMP(file_name@@@sla.hh)ATTRDUMP"))) __attribute__((annotate(R"ATTRDUMP(pattern@@@*)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$sla.hh")))  clyd;}
namespace sla{struct __attribute__((annotate(R"ATTRDUMP(file_name@@@sla.hh)ATTRDUMP"))) __attribute__((annotate(R"ATTRDUMP(pattern@@@*)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$sla.hh")))  m2av;}
namespace sla{struct __attribute__((annotate(R"ATTRDUMP(file_name@@@sla.hh)ATTRDUMP"))) __attribute__((annotate(R"ATTRDUMP(pattern@@@*)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$sla.hh")))  dr2tf;}
namespace sla{struct __attribute__((annotate(R"ATTRDUMP(file_name@@@sla.hh)ATTRDUMP"))) __attribute__((annotate(R"ATTRDUMP(pattern@@@*)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$sla.hh")))  _atms;}
namespace sla{struct __attribute__((annotate(R"ATTRDUMP(file_name@@@sla.hh)ATTRDUMP"))) __attribute__((annotate(R"ATTRDUMP(pattern@@@*)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$sla.hh")))  dcmpf;}
namespace sla{struct __attribute__((annotate(R"ATTRDUMP(file_name@@@sla.hh)ATTRDUMP"))) __attribute__((annotate(R"ATTRDUMP(pattern@@@*)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$sla.hh")))  afin;}
namespace sla{struct __attribute__((annotate(R"ATTRDUMP(file_name@@@sla.hh)ATTRDUMP"))) __attribute__((annotate(R"ATTRDUMP(pattern@@@*)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$sla.hh")))  ds2tp;}
namespace sla{struct __attribute__((annotate(R"ATTRDUMP(file_name@@@sla.hh)ATTRDUMP"))) __attribute__((annotate(R"ATTRDUMP(pattern@@@*)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$sla.hh")))  dtp2s;}
namespace sla{struct __attribute__((annotate(R"ATTRDUMP(file_name@@@sla.hh)ATTRDUMP"))) __attribute__((annotate(R"ATTRDUMP(pattern@@@*)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$sla.hh")))  fk52h;}
namespace sla{struct __attribute__((annotate(R"ATTRDUMP(file_name@@@sla.hh)ATTRDUMP"))) __attribute__((annotate(R"ATTRDUMP(pattern@@@*)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$sla.hh")))  mapqk;}
namespace sla{struct __attribute__((annotate(R"ATTRDUMP(file_name@@@sla.hh)ATTRDUMP"))) __attribute__((annotate(R"ATTRDUMP(pattern@@@*)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$sla.hh")))  ctf2r;}
namespace sla{struct __attribute__((annotate(R"ATTRDUMP(file_name@@@sla.hh)ATTRDUMP"))) __attribute__((annotate(R"ATTRDUMP(pattern@@@*)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$sla.hh")))  pertue;}
namespace sla{struct __attribute__((annotate(R"ATTRDUMP(file_name@@@sla.hh)ATTRDUMP"))) __attribute__((annotate(R"ATTRDUMP(pattern@@@*)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$sla.hh")))  atmdsp;}
namespace sla{struct __attribute__((annotate(R"ATTRDUMP(file_name@@@sla.hh)ATTRDUMP"))) __attribute__((annotate(R"ATTRDUMP(pattern@@@*)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$sla.hh")))  prebn;}
namespace sla{struct __attribute__((annotate(R"ATTRDUMP(file_name@@@sla.hh)ATTRDUMP"))) __attribute__((annotate(R"ATTRDUMP(pattern@@@*)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$sla.hh")))  h2e;}
namespace sla{struct __attribute__((annotate(R"ATTRDUMP(file_name@@@sla.hh)ATTRDUMP"))) __attribute__((annotate(R"ATTRDUMP(pattern@@@*)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$sla.hh")))  ue2el;}
namespace sla{struct __attribute__((annotate(R"ATTRDUMP(file_name@@@sla.hh)ATTRDUMP"))) __attribute__((annotate(R"ATTRDUMP(pattern@@@*)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$sla.hh")))  eg50;}
namespace sla{struct __attribute__((annotate(R"ATTRDUMP(file_name@@@sla.hh)ATTRDUMP"))) __attribute__((annotate(R"ATTRDUMP(pattern@@@*)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$sla.hh")))  invf;}
namespace sla{struct __attribute__((annotate(R"ATTRDUMP(file_name@@@sla.hh)ATTRDUMP"))) __attribute__((annotate(R"ATTRDUMP(pattern@@@*)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$sla.hh")))  fk45z;}
namespace sla{struct __attribute__((annotate(R"ATTRDUMP(file_name@@@sla.hh)ATTRDUMP"))) __attribute__((annotate(R"ATTRDUMP(pattern@@@*)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$sla.hh")))  dimxv;}
namespace sla{struct __attribute__((annotate(R"ATTRDUMP(file_name@@@sla.hh)ATTRDUMP"))) __attribute__((annotate(R"ATTRDUMP(pattern@@@*)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$sla.hh")))  daf2r;}
namespace sla{struct __attribute__((annotate(R"ATTRDUMP(file_name@@@sla.hh)ATTRDUMP"))) __attribute__((annotate(R"ATTRDUMP(pattern@@@*)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$sla.hh")))  pdq2h;}
namespace sla{struct __attribute__((annotate(R"ATTRDUMP(file_name@@@sla.hh)ATTRDUMP"))) __attribute__((annotate(R"ATTRDUMP(pattern@@@*)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$sla.hh")))  dh2e;}
namespace sla{struct __attribute__((annotate(R"ATTRDUMP(file_name@@@sla.hh)ATTRDUMP"))) __attribute__((annotate(R"ATTRDUMP(pattern@@@*)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$sla.hh")))  dtps2c;}
namespace sla{struct __attribute__((annotate(R"ATTRDUMP(file_name@@@sla.hh)ATTRDUMP"))) __attribute__((annotate(R"ATTRDUMP(pattern@@@*)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$sla.hh")))  dm2av;}
namespace sla{struct __attribute__((annotate(R"ATTRDUMP(file_name@@@sla.hh)ATTRDUMP"))) __attribute__((annotate(R"ATTRDUMP(pattern@@@*)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$sla.hh")))  prec;}
namespace sla{struct __attribute__((annotate(R"ATTRDUMP(file_name@@@sla.hh)ATTRDUMP"))) __attribute__((annotate(R"ATTRDUMP(pattern@@@*)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$sla.hh")))  plante;}
namespace sla{struct __attribute__((annotate(R"ATTRDUMP(file_name@@@sla.hh)ATTRDUMP"))) __attribute__((annotate(R"ATTRDUMP(pattern@@@*)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$sla.hh")))  precl;}
namespace sla{struct __attribute__((annotate(R"ATTRDUMP(file_name@@@sla.hh)ATTRDUMP"))) __attribute__((annotate(R"ATTRDUMP(pattern@@@*)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$sla.hh")))  kbj;}
namespace sla{struct __attribute__((annotate(R"ATTRDUMP(file_name@@@sla.hh)ATTRDUMP"))) __attribute__((annotate(R"ATTRDUMP(pattern@@@*)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$sla.hh")))  pv2ue;}
namespace sla{struct __attribute__((annotate(R"ATTRDUMP(file_name@@@sla.hh)ATTRDUMP"))) __attribute__((annotate(R"ATTRDUMP(pattern@@@*)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$sla.hh")))  dcs2c;}
namespace sla{struct __attribute__((annotate(R"ATTRDUMP(file_name@@@sla.hh)ATTRDUMP"))) __attribute__((annotate(R"ATTRDUMP(pattern@@@*)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$sla.hh")))  fk54z;}
namespace sla{struct __attribute__((annotate(R"ATTRDUMP(file_name@@@sla.hh)ATTRDUMP"))) __attribute__((annotate(R"ATTRDUMP(pattern@@@*)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$sla.hh")))  _idchf;}
namespace sla{struct __attribute__((annotate(R"ATTRDUMP(file_name@@@sla.hh)ATTRDUMP"))) __attribute__((annotate(R"ATTRDUMP(pattern@@@*)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$sla.hh")))  djcl;}
namespace sla{struct __attribute__((annotate(R"ATTRDUMP(file_name@@@sla.hh)ATTRDUMP"))) __attribute__((annotate(R"ATTRDUMP(pattern@@@*)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$sla.hh")))  dc62s;}
namespace sla{struct __attribute__((annotate(R"ATTRDUMP(file_name@@@sla.hh)ATTRDUMP"))) __attribute__((annotate(R"ATTRDUMP(pattern@@@*)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$sla.hh")))  eqgal;}
namespace sla{struct __attribute__((annotate(R"ATTRDUMP(file_name@@@sla.hh)ATTRDUMP"))) __attribute__((annotate(R"ATTRDUMP(pattern@@@*)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$sla.hh")))  ge50;}
namespace sla{struct __attribute__((annotate(R"ATTRDUMP(file_name@@@sla.hh)ATTRDUMP"))) __attribute__((annotate(R"ATTRDUMP(pattern@@@*)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$sla.hh")))  cs2c6;}
namespace sla{struct __attribute__((annotate(R"ATTRDUMP(file_name@@@sla.hh)ATTRDUMP"))) __attribute__((annotate(R"ATTRDUMP(pattern@@@*)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$sla.hh")))  s2tp;}
namespace sla{struct __attribute__((annotate(R"ATTRDUMP(file_name@@@sla.hh)ATTRDUMP"))) __attribute__((annotate(R"ATTRDUMP(pattern@@@*)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$sla.hh")))  cc2s;}
namespace sla{struct __attribute__((annotate(R"ATTRDUMP(file_name@@@sla.hh)ATTRDUMP"))) __attribute__((annotate(R"ATTRDUMP(pattern@@@*)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$sla.hh")))  nut;}
namespace sla{struct __attribute__((annotate(R"ATTRDUMP(file_name@@@sla.hh)ATTRDUMP"))) __attribute__((annotate(R"ATTRDUMP(pattern@@@*)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$sla.hh")))  v2tp;}
namespace sla{struct __attribute__((annotate(R"ATTRDUMP(file_name@@@sla.hh)ATTRDUMP"))) __attribute__((annotate(R"ATTRDUMP(pattern@@@*)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$sla.hh")))  djcal;}
namespace sla{struct __attribute__((annotate(R"ATTRDUMP(file_name@@@sla.hh)ATTRDUMP"))) __attribute__((annotate(R"ATTRDUMP(pattern@@@*)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$sla.hh")))  dtpv2c;}
namespace sla{struct __attribute__((annotate(R"ATTRDUMP(file_name@@@sla.hh)ATTRDUMP"))) __attribute__((annotate(R"ATTRDUMP(pattern@@@*)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$sla.hh")))  _idchi;}
namespace sla{struct __attribute__((annotate(R"ATTRDUMP(file_name@@@sla.hh)ATTRDUMP"))) __attribute__((annotate(R"ATTRDUMP(pattern@@@*)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$sla.hh")))  ds2c6;}
namespace sla{struct __attribute__((annotate(R"ATTRDUMP(file_name@@@sla.hh)ATTRDUMP"))) __attribute__((annotate(R"ATTRDUMP(pattern@@@*)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$sla.hh")))  etrms;}
namespace sla{struct __attribute__((annotate(R"ATTRDUMP(file_name@@@sla.hh)ATTRDUMP"))) __attribute__((annotate(R"ATTRDUMP(pattern@@@*)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$sla.hh")))  refcoq;}
namespace sla{struct __attribute__((annotate(R"ATTRDUMP(file_name@@@sla.hh)ATTRDUMP"))) __attribute__((annotate(R"ATTRDUMP(pattern@@@*)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$sla.hh")))  eqecl;}
namespace sla{struct __attribute__((annotate(R"ATTRDUMP(file_name@@@sla.hh)ATTRDUMP"))) __attribute__((annotate(R"ATTRDUMP(pattern@@@*)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$sla.hh")))  tps2c;}
namespace sla{struct __attribute__((annotate(R"ATTRDUMP(file_name@@@sla.hh)ATTRDUMP"))) __attribute__((annotate(R"ATTRDUMP(pattern@@@*)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$sla.hh")))  fk425;}
namespace sla{struct __attribute__((annotate(R"ATTRDUMP(file_name@@@sla.hh)ATTRDUMP"))) __attribute__((annotate(R"ATTRDUMP(pattern@@@*)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$sla.hh")))  dv2tp;}
namespace sla{struct __attribute__((annotate(R"ATTRDUMP(file_name@@@sla.hh)ATTRDUMP"))) __attribute__((annotate(R"ATTRDUMP(pattern@@@*)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$sla.hh")))  tp2s;}
namespace sla{struct __attribute__((annotate(R"ATTRDUMP(file_name@@@sla.hh)ATTRDUMP"))) __attribute__((annotate(R"ATTRDUMP(pattern@@@*)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$sla.hh")))  dmoon;}
namespace sla{struct __attribute__((annotate(R"ATTRDUMP(file_name@@@sla.hh)ATTRDUMP"))) __attribute__((annotate(R"ATTRDUMP(pattern@@@*)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$sla.hh")))  caf2r;}
namespace sla{struct __attribute__((annotate(R"ATTRDUMP(file_name@@@sla.hh)ATTRDUMP"))) __attribute__((annotate(R"ATTRDUMP(pattern@@@*)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$sla.hh")))  earth;}
namespace sla{struct __attribute__((annotate(R"ATTRDUMP(file_name@@@sla.hh)ATTRDUMP"))) __attribute__((annotate(R"ATTRDUMP(pattern@@@*)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$sla.hh")))  prenut;}
namespace sla{struct __attribute__((annotate(R"ATTRDUMP(file_name@@@sla.hh)ATTRDUMP"))) __attribute__((annotate(R"ATTRDUMP(pattern@@@*)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$sla.hh")))  xy2xy;}
namespace sla{struct __attribute__((annotate(R"ATTRDUMP(file_name@@@sla.hh)ATTRDUMP"))) __attribute__((annotate(R"ATTRDUMP(pattern@@@*)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$sla.hh")))  ue2pv;}
namespace sla{struct __attribute__((annotate(R"ATTRDUMP(file_name@@@sla.hh)ATTRDUMP"))) __attribute__((annotate(R"ATTRDUMP(pattern@@@*)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$sla.hh")))  supgal;}
namespace sla{struct __attribute__((annotate(R"ATTRDUMP(file_name@@@sla.hh)ATTRDUMP"))) __attribute__((annotate(R"ATTRDUMP(pattern@@@*)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$sla.hh")))  dr2af;}
namespace sla{struct __attribute__((annotate(R"ATTRDUMP(file_name@@@sla.hh)ATTRDUMP"))) __attribute__((annotate(R"ATTRDUMP(pattern@@@*)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$sla.hh")))  addet;}
namespace sla{struct __attribute__((annotate(R"ATTRDUMP(file_name@@@sla.hh)ATTRDUMP"))) __attribute__((annotate(R"ATTRDUMP(pattern@@@*)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$sla.hh")))  refv;}
namespace sla{struct __attribute__((annotate(R"ATTRDUMP(file_name@@@sla.hh)ATTRDUMP"))) __attribute__((annotate(R"ATTRDUMP(pattern@@@*)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$sla.hh")))  _atmt;}
namespace sla{struct __attribute__((annotate(R"ATTRDUMP(file_name@@@sla.hh)ATTRDUMP"))) __attribute__((annotate(R"ATTRDUMP(pattern@@@*)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$sla.hh")))  cc62s;}
namespace sla{struct __attribute__((annotate(R"ATTRDUMP(file_name@@@sla.hh)ATTRDUMP"))) __attribute__((annotate(R"ATTRDUMP(pattern@@@*)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$sla.hh")))  subet;}
namespace sla{struct __attribute__((annotate(R"ATTRDUMP(file_name@@@sla.hh)ATTRDUMP"))) __attribute__((annotate(R"ATTRDUMP(pattern@@@*)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$sla.hh")))  cldj;}
namespace sla{struct __attribute__((annotate(R"ATTRDUMP(file_name@@@sla.hh)ATTRDUMP"))) __attribute__((annotate(R"ATTRDUMP(pattern@@@*)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$sla.hh")))  dtf2r;}
namespace sla{struct __attribute__((annotate(R"ATTRDUMP(file_name@@@sla.hh)ATTRDUMP"))) __attribute__((annotate(R"ATTRDUMP(pattern@@@*)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$sla.hh")))  aop;}
namespace sla{struct __attribute__((annotate(R"ATTRDUMP(file_name@@@sla.hh)ATTRDUMP"))) __attribute__((annotate(R"ATTRDUMP(pattern@@@*)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$sla.hh")))  rdplan;}
namespace sla{struct __attribute__((annotate(R"ATTRDUMP(file_name@@@sla.hh)ATTRDUMP"))) __attribute__((annotate(R"ATTRDUMP(pattern@@@*)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$sla.hh")))  dbjin;}
namespace sla{struct __attribute__((annotate(R"ATTRDUMP(file_name@@@sla.hh)ATTRDUMP"))) __attribute__((annotate(R"ATTRDUMP(pattern@@@*)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$sla.hh")))  tpv2c;}
namespace sla{struct __attribute__((annotate(R"ATTRDUMP(file_name@@@sla.hh)ATTRDUMP"))) __attribute__((annotate(R"ATTRDUMP(pattern@@@*)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$sla.hh")))  oapqk;}
namespace sla{struct __attribute__((annotate(R"ATTRDUMP(file_name@@@sla.hh)ATTRDUMP"))) __attribute__((annotate(R"ATTRDUMP(pattern@@@*)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$sla.hh")))  pda2h;}
namespace sla{struct __attribute__((annotate(R"ATTRDUMP(file_name@@@sla.hh)ATTRDUMP"))) __attribute__((annotate(R"ATTRDUMP(pattern@@@*)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$sla.hh")))  aopqk;}
namespace sla{struct __attribute__((annotate(R"ATTRDUMP(file_name@@@sla.hh)ATTRDUMP"))) __attribute__((annotate(R"ATTRDUMP(pattern@@@*)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$sla.hh")))  pm;}
namespace sla{struct __attribute__((annotate(R"ATTRDUMP(file_name@@@sla.hh)ATTRDUMP"))) __attribute__((annotate(R"ATTRDUMP(pattern@@@*)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$sla.hh")))  intin;}
namespace sla{struct __attribute__((annotate(R"ATTRDUMP(file_name@@@sla.hh)ATTRDUMP"))) __attribute__((annotate(R"ATTRDUMP(pattern@@@*)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$sla.hh")))  cr2tf;}
namespace sla{struct __attribute__((annotate(R"ATTRDUMP(file_name@@@sla.hh)ATTRDUMP"))) __attribute__((annotate(R"ATTRDUMP(pattern@@@*)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$sla.hh")))  planet;}
namespace sla{struct __attribute__((annotate(R"ATTRDUMP(file_name@@@sla.hh)ATTRDUMP"))) __attribute__((annotate(R"ATTRDUMP(pattern@@@*)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$sla.hh")))  vxv;}
namespace sla{struct __attribute__((annotate(R"ATTRDUMP(file_name@@@sla.hh)ATTRDUMP"))) __attribute__((annotate(R"ATTRDUMP(pattern@@@*)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$sla.hh")))  pcd;}
namespace sla{struct __attribute__((annotate(R"ATTRDUMP(file_name@@@sla.hh)ATTRDUMP"))) __attribute__((annotate(R"ATTRDUMP(pattern@@@*)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$sla.hh")))  ecor;}
namespace sla{struct __attribute__((annotate(R"ATTRDUMP(file_name@@@sla.hh)ATTRDUMP"))) __attribute__((annotate(R"ATTRDUMP(pattern@@@*)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$sla.hh")))  flotin;}
namespace sla{struct __attribute__((annotate(R"ATTRDUMP(file_name@@@sla.hh)ATTRDUMP"))) __attribute__((annotate(R"ATTRDUMP(pattern@@@*)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$sla.hh")))  dtp2v;}
namespace sla{struct __attribute__((annotate(R"ATTRDUMP(file_name@@@sla.hh)ATTRDUMP"))) __attribute__((annotate(R"ATTRDUMP(pattern@@@*)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$sla.hh")))  e2h;}
namespace sla{struct __attribute__((annotate(R"ATTRDUMP(file_name@@@sla.hh)ATTRDUMP"))) __attribute__((annotate(R"ATTRDUMP(pattern@@@*)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$sla.hh")))  fk524;}
)DICTFWDDCLS";
    static const char* payloadCode = R"DICTPAYLOAD(
#line 1 "sladOdict dictionary payload"

#ifndef HAVEJPP
  #define HAVEJPP 1
#endif

#define _BACKWARD_BACKWARD_WARNING_H
// Inline headers
#include "sla.hh"

#undef  _BACKWARD_BACKWARD_WARNING_H
)DICTPAYLOAD";
    static const char* classesHeaders[] = {
"", payloadCode, "@",
"sla::_atms", payloadCode, "@",
"sla::_atmt", payloadCode, "@",
"sla::_idchf", payloadCode, "@",
"sla::_idchi", payloadCode, "@",
"sla::_pointable<int>", payloadCode, "@",
"sla::addet", payloadCode, "@",
"sla::afin", payloadCode, "@",
"sla::airmas", payloadCode, "@",
"sla::altaz", payloadCode, "@",
"sla::amp", payloadCode, "@",
"sla::ampqk", payloadCode, "@",
"sla::aop", payloadCode, "@",
"sla::aoppa", payloadCode, "@",
"sla::aoppat", payloadCode, "@",
"sla::aopqk", payloadCode, "@",
"sla::atmdsp", payloadCode, "@",
"sla::av2m", payloadCode, "@",
"sla::bear", payloadCode, "@",
"sla::caf2r", payloadCode, "@",
"sla::caldj", payloadCode, "@",
"sla::calyd", payloadCode, "@",
"sla::cc2s", payloadCode, "@",
"sla::cc62s", payloadCode, "@",
"sla::cd2tf", payloadCode, "@",
"sla::cldj", payloadCode, "@",
"sla::clyd", payloadCode, "@",
"sla::cr2af", payloadCode, "@",
"sla::cr2tf", payloadCode, "@",
"sla::cs2c", payloadCode, "@",
"sla::cs2c6", payloadCode, "@",
"sla::ctf2d", payloadCode, "@",
"sla::ctf2r", payloadCode, "@",
"sla::daf2r", payloadCode, "@",
"sla::dafin", payloadCode, "@",
"sla::dat", payloadCode, "@",
"sla::dav2m", payloadCode, "@",
"sla::dbear", payloadCode, "@",
"sla::dbjin", payloadCode, "@",
"sla::dc62s", payloadCode, "@",
"sla::dcc2s", payloadCode, "@",
"sla::dcmpf", payloadCode, "@",
"sla::dcs2c", payloadCode, "@",
"sla::dd2tf", payloadCode, "@",
"sla::de2h", payloadCode, "@",
"sla::deuler", payloadCode, "@",
"sla::dfltin", payloadCode, "@",
"sla::dh2e", payloadCode, "@",
"sla::dimxv", payloadCode, "@",
"sla::djcal", payloadCode, "@",
"sla::djcl", payloadCode, "@",
"sla::dm2av", payloadCode, "@",
"sla::dmoon", payloadCode, "@",
"sla::dmxm", payloadCode, "@",
"sla::dmxv", payloadCode, "@",
"sla::dpav", payloadCode, "@",
"sla::dr2af", payloadCode, "@",
"sla::dr2tf", payloadCode, "@",
"sla::drange", payloadCode, "@",
"sla::dranrm", payloadCode, "@",
"sla::ds2c6", payloadCode, "@",
"sla::ds2tp", payloadCode, "@",
"sla::dsep", payloadCode, "@",
"sla::dsepv", payloadCode, "@",
"sla::dt", payloadCode, "@",
"sla::dtf2d", payloadCode, "@",
"sla::dtf2r", payloadCode, "@",
"sla::dtp2s", payloadCode, "@",
"sla::dtp2v", payloadCode, "@",
"sla::dtps2c", payloadCode, "@",
"sla::dtpv2c", payloadCode, "@",
"sla::dtt", payloadCode, "@",
"sla::dv2tp", payloadCode, "@",
"sla::dvdv", payloadCode, "@",
"sla::dvn", payloadCode, "@",
"sla::dvxv", payloadCode, "@",
"sla::e2h", payloadCode, "@",
"sla::earth", payloadCode, "@",
"sla::ecleq", payloadCode, "@",
"sla::ecmat", payloadCode, "@",
"sla::ecor", payloadCode, "@",
"sla::eg50", payloadCode, "@",
"sla::el2ue", payloadCode, "@",
"sla::epb", payloadCode, "@",
"sla::epb2d", payloadCode, "@",
"sla::epco", payloadCode, "@",
"sla::epj", payloadCode, "@",
"sla::epj2d", payloadCode, "@",
"sla::epv", payloadCode, "@",
"sla::eqecl", payloadCode, "@",
"sla::eqeqx", payloadCode, "@",
"sla::eqgal", payloadCode, "@",
"sla::etrms", payloadCode, "@",
"sla::euler", payloadCode, "@",
"sla::fk425", payloadCode, "@",
"sla::fk45z", payloadCode, "@",
"sla::fk524", payloadCode, "@",
"sla::fk52h", payloadCode, "@",
"sla::fk54z", payloadCode, "@",
"sla::fk5hz", payloadCode, "@",
"sla::flotin", payloadCode, "@",
"sla::galeq", payloadCode, "@",
"sla::galsup", payloadCode, "@",
"sla::ge50", payloadCode, "@",
"sla::geoc", payloadCode, "@",
"sla::gmst", payloadCode, "@",
"sla::gmsta", payloadCode, "@",
"sla::h2e", payloadCode, "@",
"sla::h2fk5", payloadCode, "@",
"sla::imxv", payloadCode, "@",
"sla::intin", payloadCode, "@",
"sla::invf", payloadCode, "@",
"sla::kbj", payloadCode, "@",
"sla::m2av", payloadCode, "@",
"sla::map", payloadCode, "@",
"sla::mappa", payloadCode, "@",
"sla::mapqk", payloadCode, "@",
"sla::mapqkz", payloadCode, "@",
"sla::moon", payloadCode, "@",
"sla::mxm", payloadCode, "@",
"sla::mxv", payloadCode, "@",
"sla::nut", payloadCode, "@",
"sla::nutc", payloadCode, "@",
"sla::nutc80", payloadCode, "@",
"sla::oap", payloadCode, "@",
"sla::oapqk", payloadCode, "@",
"sla::operator<<", payloadCode, "@",
"sla::pa", payloadCode, "@",
"sla::pav", payloadCode, "@",
"sla::pcd", payloadCode, "@",
"sla::pda2h", payloadCode, "@",
"sla::pdq2h", payloadCode, "@",
"sla::pertel", payloadCode, "@",
"sla::pertue", payloadCode, "@",
"sla::planel", payloadCode, "@",
"sla::planet", payloadCode, "@",
"sla::plante", payloadCode, "@",
"sla::plantu", payloadCode, "@",
"sla::pm", payloadCode, "@",
"sla::polmo", payloadCode, "@",
"sla::prebn", payloadCode, "@",
"sla::prec", payloadCode, "@",
"sla::preces", payloadCode, "@",
"sla::precl", payloadCode, "@",
"sla::prenut", payloadCode, "@",
"sla::pv2el", payloadCode, "@",
"sla::pv2ue", payloadCode, "@",
"sla::range", payloadCode, "@",
"sla::ranorm", payloadCode, "@",
"sla::rcc", payloadCode, "@",
"sla::rdplan", payloadCode, "@",
"sla::refco", payloadCode, "@",
"sla::refcoq", payloadCode, "@",
"sla::refro", payloadCode, "@",
"sla::refv", payloadCode, "@",
"sla::refz", payloadCode, "@",
"sla::rverot", payloadCode, "@",
"sla::rvgalc", payloadCode, "@",
"sla::rvlg", payloadCode, "@",
"sla::rvlsrd", payloadCode, "@",
"sla::rvlsrk", payloadCode, "@",
"sla::s2tp", payloadCode, "@",
"sla::sep", payloadCode, "@",
"sla::sepv", payloadCode, "@",
"sla::subet", payloadCode, "@",
"sla::supgal", payloadCode, "@",
"sla::tp2s", payloadCode, "@",
"sla::tp2v", payloadCode, "@",
"sla::tps2c", payloadCode, "@",
"sla::tpv2c", payloadCode, "@",
"sla::ue2el", payloadCode, "@",
"sla::ue2pv", payloadCode, "@",
"sla::unpcd", payloadCode, "@",
"sla::v2tp", payloadCode, "@",
"sla::vdv", payloadCode, "@",
"sla::vn", payloadCode, "@",
"sla::vxv", payloadCode, "@",
"sla::xy2xy", payloadCode, "@",
"sla::zd", payloadCode, "@",
"sla__atms_", payloadCode, "@",
"sla__atmt_", payloadCode, "@",
"sla__idchf_", payloadCode, "@",
"sla__idchi_", payloadCode, "@",
"sla_addet_", payloadCode, "@",
"sla_afin_", payloadCode, "@",
"sla_airmas_", payloadCode, "@",
"sla_altaz_", payloadCode, "@",
"sla_amp_", payloadCode, "@",
"sla_ampqk_", payloadCode, "@",
"sla_aop_", payloadCode, "@",
"sla_aoppa_", payloadCode, "@",
"sla_aoppat_", payloadCode, "@",
"sla_aopqk_", payloadCode, "@",
"sla_atmdsp_", payloadCode, "@",
"sla_av2m_", payloadCode, "@",
"sla_bear_", payloadCode, "@",
"sla_caf2r_", payloadCode, "@",
"sla_caldj_", payloadCode, "@",
"sla_calyd_", payloadCode, "@",
"sla_cc2s_", payloadCode, "@",
"sla_cc62s_", payloadCode, "@",
"sla_cd2tf_", payloadCode, "@",
"sla_cldj_", payloadCode, "@",
"sla_clyd_", payloadCode, "@",
"sla_cr2af_", payloadCode, "@",
"sla_cr2tf_", payloadCode, "@",
"sla_cs2c6_", payloadCode, "@",
"sla_cs2c_", payloadCode, "@",
"sla_ctf2d_", payloadCode, "@",
"sla_ctf2r_", payloadCode, "@",
"sla_daf2r_", payloadCode, "@",
"sla_dafin_", payloadCode, "@",
"sla_dat_", payloadCode, "@",
"sla_dav2m_", payloadCode, "@",
"sla_dbear_", payloadCode, "@",
"sla_dbjin_", payloadCode, "@",
"sla_dc62s_", payloadCode, "@",
"sla_dcc2s_", payloadCode, "@",
"sla_dcmpf_", payloadCode, "@",
"sla_dcs2c_", payloadCode, "@",
"sla_dd2tf_", payloadCode, "@",
"sla_de2h_", payloadCode, "@",
"sla_deuler_", payloadCode, "@",
"sla_dfltin_", payloadCode, "@",
"sla_dh2e_", payloadCode, "@",
"sla_dimxv_", payloadCode, "@",
"sla_djcal_", payloadCode, "@",
"sla_djcl_", payloadCode, "@",
"sla_dm2av_", payloadCode, "@",
"sla_dmoon_", payloadCode, "@",
"sla_dmxm_", payloadCode, "@",
"sla_dmxv_", payloadCode, "@",
"sla_dpav_", payloadCode, "@",
"sla_dr2af_", payloadCode, "@",
"sla_dr2tf_", payloadCode, "@",
"sla_drange_", payloadCode, "@",
"sla_dranrm_", payloadCode, "@",
"sla_ds2c6_", payloadCode, "@",
"sla_ds2tp_", payloadCode, "@",
"sla_dsep_", payloadCode, "@",
"sla_dsepv_", payloadCode, "@",
"sla_dt_", payloadCode, "@",
"sla_dtf2d_", payloadCode, "@",
"sla_dtf2r_", payloadCode, "@",
"sla_dtp2s_", payloadCode, "@",
"sla_dtp2v_", payloadCode, "@",
"sla_dtps2c_", payloadCode, "@",
"sla_dtpv2c_", payloadCode, "@",
"sla_dtt_", payloadCode, "@",
"sla_dv2tp_", payloadCode, "@",
"sla_dvdv_", payloadCode, "@",
"sla_dvn_", payloadCode, "@",
"sla_dvxv_", payloadCode, "@",
"sla_e2h_", payloadCode, "@",
"sla_earth_", payloadCode, "@",
"sla_ecleq_", payloadCode, "@",
"sla_ecmat_", payloadCode, "@",
"sla_ecor_", payloadCode, "@",
"sla_eg50_", payloadCode, "@",
"sla_el2ue_", payloadCode, "@",
"sla_epb2d_", payloadCode, "@",
"sla_epb_", payloadCode, "@",
"sla_epco_", payloadCode, "@",
"sla_epj2d_", payloadCode, "@",
"sla_epj_", payloadCode, "@",
"sla_epv_", payloadCode, "@",
"sla_eqecl_", payloadCode, "@",
"sla_eqeqx_", payloadCode, "@",
"sla_eqgal_", payloadCode, "@",
"sla_etrms_", payloadCode, "@",
"sla_euler_", payloadCode, "@",
"sla_fk425_", payloadCode, "@",
"sla_fk45z_", payloadCode, "@",
"sla_fk524_", payloadCode, "@",
"sla_fk52h_", payloadCode, "@",
"sla_fk54z_", payloadCode, "@",
"sla_fk5hz_", payloadCode, "@",
"sla_flotin_", payloadCode, "@",
"sla_galeq_", payloadCode, "@",
"sla_galsup_", payloadCode, "@",
"sla_ge50_", payloadCode, "@",
"sla_geoc_", payloadCode, "@",
"sla_gmst_", payloadCode, "@",
"sla_gmsta_", payloadCode, "@",
"sla_h2e_", payloadCode, "@",
"sla_h2fk5_", payloadCode, "@",
"sla_imxv_", payloadCode, "@",
"sla_intin_", payloadCode, "@",
"sla_invf_", payloadCode, "@",
"sla_kbj_", payloadCode, "@",
"sla_m2av_", payloadCode, "@",
"sla_map_", payloadCode, "@",
"sla_mappa_", payloadCode, "@",
"sla_mapqk_", payloadCode, "@",
"sla_mapqkz_", payloadCode, "@",
"sla_moon_", payloadCode, "@",
"sla_mxm_", payloadCode, "@",
"sla_mxv_", payloadCode, "@",
"sla_nut_", payloadCode, "@",
"sla_nutc80_", payloadCode, "@",
"sla_nutc_", payloadCode, "@",
"sla_oap_", payloadCode, "@",
"sla_oapqk_", payloadCode, "@",
"sla_pa_", payloadCode, "@",
"sla_pav_", payloadCode, "@",
"sla_pcd_", payloadCode, "@",
"sla_pda2h_", payloadCode, "@",
"sla_pdq2h_", payloadCode, "@",
"sla_pertel_", payloadCode, "@",
"sla_pertue_", payloadCode, "@",
"sla_planel_", payloadCode, "@",
"sla_planet_", payloadCode, "@",
"sla_plante_", payloadCode, "@",
"sla_plantu_", payloadCode, "@",
"sla_pm_", payloadCode, "@",
"sla_polmo_", payloadCode, "@",
"sla_prebn_", payloadCode, "@",
"sla_prec_", payloadCode, "@",
"sla_preces_", payloadCode, "@",
"sla_precl_", payloadCode, "@",
"sla_prenut_", payloadCode, "@",
"sla_pv2el_", payloadCode, "@",
"sla_pv2ue_", payloadCode, "@",
"sla_range_", payloadCode, "@",
"sla_ranorm_", payloadCode, "@",
"sla_rcc_", payloadCode, "@",
"sla_rdplan_", payloadCode, "@",
"sla_refco_", payloadCode, "@",
"sla_refcoq_", payloadCode, "@",
"sla_refro_", payloadCode, "@",
"sla_refv_", payloadCode, "@",
"sla_refz_", payloadCode, "@",
"sla_rverot_", payloadCode, "@",
"sla_rvgalc_", payloadCode, "@",
"sla_rvlg_", payloadCode, "@",
"sla_rvlsrd_", payloadCode, "@",
"sla_rvlsrk_", payloadCode, "@",
"sla_s2tp_", payloadCode, "@",
"sla_sep_", payloadCode, "@",
"sla_sepv_", payloadCode, "@",
"sla_subet_", payloadCode, "@",
"sla_supgal_", payloadCode, "@",
"sla_tp2s_", payloadCode, "@",
"sla_tp2v_", payloadCode, "@",
"sla_tps2c_", payloadCode, "@",
"sla_tpv2c_", payloadCode, "@",
"sla_ue2el_", payloadCode, "@",
"sla_ue2pv_", payloadCode, "@",
"sla_unpcd_", payloadCode, "@",
"sla_v2tp_", payloadCode, "@",
"sla_vdv_", payloadCode, "@",
"sla_vn_", payloadCode, "@",
"sla_vxv_", payloadCode, "@",
"sla_xy2xy_", payloadCode, "@",
"sla_zd_", payloadCode, "@",
nullptr
};
    static bool isInitialized = false;
    if (!isInitialized) {
      TROOT::RegisterModule("sla.dict",
        headers, includePaths, payloadCode, fwdDeclCode,
        TriggerDictionaryInitialization_sladOdict_Impl, {}, classesHeaders, /*hasCxxModule*/false);
      isInitialized = true;
    }
  }
  static struct DictInit {
    DictInit() {
      TriggerDictionaryInitialization_sladOdict_Impl();
    }
  } __TheDictionaryInitializer;
}
void TriggerDictionaryInitialization_sladOdict() {
  TriggerDictionaryInitialization_sladOdict_Impl();
}