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

#define R__DICTIONARY_FILENAME AntaresDAQDictionary
#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 "Ars.hh"
#include "FramePreamble.hh"
#include "TimeSlice.hh"
#include "PhysicsEvent.hh"
#include "EventPreamble.hh"

// Header files passed via #pragma extra_include

namespace ROOT {
   static void *new_ARS_Item(void *p = 0);
   static void *newArray_ARS_Item(Long_t size, void *p);
   static void delete_ARS_Item(void *p);
   static void deleteArray_ARS_Item(void *p);
   static void destruct_ARS_Item(void *p);
   static void streamer_ARS_Item(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::ARS_Item*)
   {
      ::ARS_Item *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::ARS_Item >(0);
      static ::ROOT::TGenericClassInfo 
         instance("ARS_Item", ::ARS_Item::Class_Version(), "", 27,
                  typeid(::ARS_Item), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &::ARS_Item::Dictionary, isa_proxy, 17,
                  sizeof(::ARS_Item) );
      instance.SetNew(&new_ARS_Item);
      instance.SetNewArray(&newArray_ARS_Item);
      instance.SetDelete(&delete_ARS_Item);
      instance.SetDeleteArray(&deleteArray_ARS_Item);
      instance.SetDestructor(&destruct_ARS_Item);
      instance.SetStreamerFunc(&streamer_ARS_Item);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::ARS_Item*)
   {
      return GenerateInitInstanceLocal((::ARS_Item*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::ARS_Item*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
} // end of namespace ROOT

namespace ROOT {
   static void *new_Status_Item(void *p = 0);
   static void *newArray_Status_Item(Long_t size, void *p);
   static void delete_Status_Item(void *p);
   static void deleteArray_Status_Item(void *p);
   static void destruct_Status_Item(void *p);
   static void streamer_Status_Item(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::Status_Item*)
   {
      ::Status_Item *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::Status_Item >(0);
      static ::ROOT::TGenericClassInfo 
         instance("Status_Item", ::Status_Item::Class_Version(), "", 41,
                  typeid(::Status_Item), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &::Status_Item::Dictionary, isa_proxy, 17,
                  sizeof(::Status_Item) );
      instance.SetNew(&new_Status_Item);
      instance.SetNewArray(&newArray_Status_Item);
      instance.SetDelete(&delete_Status_Item);
      instance.SetDeleteArray(&deleteArray_Status_Item);
      instance.SetDestructor(&destruct_Status_Item);
      instance.SetStreamerFunc(&streamer_Status_Item);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::Status_Item*)
   {
      return GenerateInitInstanceLocal((::Status_Item*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::Status_Item*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
} // end of namespace ROOT

namespace ROOT {
   static void *new_RTS_Item(void *p = 0);
   static void *newArray_RTS_Item(Long_t size, void *p);
   static void delete_RTS_Item(void *p);
   static void deleteArray_RTS_Item(void *p);
   static void destruct_RTS_Item(void *p);
   static void streamer_RTS_Item(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::RTS_Item*)
   {
      ::RTS_Item *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::RTS_Item >(0);
      static ::ROOT::TGenericClassInfo 
         instance("RTS_Item", ::RTS_Item::Class_Version(), "", 83,
                  typeid(::RTS_Item), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &::RTS_Item::Dictionary, isa_proxy, 17,
                  sizeof(::RTS_Item) );
      instance.SetNew(&new_RTS_Item);
      instance.SetNewArray(&newArray_RTS_Item);
      instance.SetDelete(&delete_RTS_Item);
      instance.SetDeleteArray(&deleteArray_RTS_Item);
      instance.SetDestructor(&destruct_RTS_Item);
      instance.SetStreamerFunc(&streamer_RTS_Item);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::RTS_Item*)
   {
      return GenerateInitInstanceLocal((::RTS_Item*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::RTS_Item*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
} // end of namespace ROOT

namespace ROOT {
   static void *new_CRM_Item(void *p = 0);
   static void *newArray_CRM_Item(Long_t size, void *p);
   static void delete_CRM_Item(void *p);
   static void deleteArray_CRM_Item(void *p);
   static void destruct_CRM_Item(void *p);
   static void streamer_CRM_Item(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::CRM_Item*)
   {
      ::CRM_Item *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::CRM_Item >(0);
      static ::ROOT::TGenericClassInfo 
         instance("CRM_Item", ::CRM_Item::Class_Version(), "", 102,
                  typeid(::CRM_Item), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &::CRM_Item::Dictionary, isa_proxy, 17,
                  sizeof(::CRM_Item) );
      instance.SetNew(&new_CRM_Item);
      instance.SetNewArray(&newArray_CRM_Item);
      instance.SetDelete(&delete_CRM_Item);
      instance.SetDeleteArray(&deleteArray_CRM_Item);
      instance.SetDestructor(&destruct_CRM_Item);
      instance.SetStreamerFunc(&streamer_CRM_Item);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::CRM_Item*)
   {
      return GenerateInitInstanceLocal((::CRM_Item*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::CRM_Item*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
} // end of namespace ROOT

namespace ROOT {
   static void *new_SPE_Item(void *p = 0);
   static void *newArray_SPE_Item(Long_t size, void *p);
   static void delete_SPE_Item(void *p);
   static void deleteArray_SPE_Item(void *p);
   static void destruct_SPE_Item(void *p);
   static void streamer_SPE_Item(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::SPE_Item*)
   {
      ::SPE_Item *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::SPE_Item >(0);
      static ::ROOT::TGenericClassInfo 
         instance("SPE_Item", ::SPE_Item::Class_Version(), "", 142,
                  typeid(::SPE_Item), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &::SPE_Item::Dictionary, isa_proxy, 17,
                  sizeof(::SPE_Item) );
      instance.SetNew(&new_SPE_Item);
      instance.SetNewArray(&newArray_SPE_Item);
      instance.SetDelete(&delete_SPE_Item);
      instance.SetDeleteArray(&deleteArray_SPE_Item);
      instance.SetDestructor(&destruct_SPE_Item);
      instance.SetStreamerFunc(&streamer_SPE_Item);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::SPE_Item*)
   {
      return GenerateInitInstanceLocal((::SPE_Item*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::SPE_Item*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
} // end of namespace ROOT

namespace ROOT {
   static void *new_AWF_Sample(void *p = 0);
   static void *newArray_AWF_Sample(Long_t size, void *p);
   static void delete_AWF_Sample(void *p);
   static void deleteArray_AWF_Sample(void *p);
   static void destruct_AWF_Sample(void *p);
   static void streamer_AWF_Sample(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::AWF_Sample*)
   {
      ::AWF_Sample *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::AWF_Sample >(0);
      static ::ROOT::TGenericClassInfo 
         instance("AWF_Sample", ::AWF_Sample::Class_Version(), "", 188,
                  typeid(::AWF_Sample), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &::AWF_Sample::Dictionary, isa_proxy, 17,
                  sizeof(::AWF_Sample) );
      instance.SetNew(&new_AWF_Sample);
      instance.SetNewArray(&newArray_AWF_Sample);
      instance.SetDelete(&delete_AWF_Sample);
      instance.SetDeleteArray(&deleteArray_AWF_Sample);
      instance.SetDestructor(&destruct_AWF_Sample);
      instance.SetStreamerFunc(&streamer_AWF_Sample);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::AWF_Sample*)
   {
      return GenerateInitInstanceLocal((::AWF_Sample*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::AWF_Sample*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
} // end of namespace ROOT

namespace ROOT {
   static void *new_DWF_Sample(void *p = 0);
   static void *newArray_DWF_Sample(Long_t size, void *p);
   static void delete_DWF_Sample(void *p);
   static void deleteArray_DWF_Sample(void *p);
   static void destruct_DWF_Sample(void *p);
   static void streamer_DWF_Sample(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::DWF_Sample*)
   {
      ::DWF_Sample *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::DWF_Sample >(0);
      static ::ROOT::TGenericClassInfo 
         instance("DWF_Sample", ::DWF_Sample::Class_Version(), "", 216,
                  typeid(::DWF_Sample), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &::DWF_Sample::Dictionary, isa_proxy, 17,
                  sizeof(::DWF_Sample) );
      instance.SetNew(&new_DWF_Sample);
      instance.SetNewArray(&newArray_DWF_Sample);
      instance.SetDelete(&delete_DWF_Sample);
      instance.SetDeleteArray(&deleteArray_DWF_Sample);
      instance.SetDestructor(&destruct_DWF_Sample);
      instance.SetStreamerFunc(&streamer_DWF_Sample);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::DWF_Sample*)
   {
      return GenerateInitInstanceLocal((::DWF_Sample*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::DWF_Sample*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
} // end of namespace ROOT

namespace ROOT {
   static void *new_WF_Header(void *p = 0);
   static void *newArray_WF_Header(Long_t size, void *p);
   static void delete_WF_Header(void *p);
   static void deleteArray_WF_Header(void *p);
   static void destruct_WF_Header(void *p);
   static void streamer_WF_Header(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::WF_Header*)
   {
      ::WF_Header *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::WF_Header >(0);
      static ::ROOT::TGenericClassInfo 
         instance("WF_Header", ::WF_Header::Class_Version(), "", 245,
                  typeid(::WF_Header), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &::WF_Header::Dictionary, isa_proxy, 17,
                  sizeof(::WF_Header) );
      instance.SetNew(&new_WF_Header);
      instance.SetNewArray(&newArray_WF_Header);
      instance.SetDelete(&delete_WF_Header);
      instance.SetDeleteArray(&deleteArray_WF_Header);
      instance.SetDestructor(&destruct_WF_Header);
      instance.SetStreamerFunc(&streamer_WF_Header);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::WF_Header*)
   {
      return GenerateInitInstanceLocal((::WF_Header*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::WF_Header*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
} // end of namespace ROOT

namespace ROOT {
   static TClass *WF_ItemlEAWF_SamplegR_Dictionary();
   static void WF_ItemlEAWF_SamplegR_TClassManip(TClass*);
   static void *new_WF_ItemlEAWF_SamplegR(void *p = 0);
   static void *newArray_WF_ItemlEAWF_SamplegR(Long_t size, void *p);
   static void delete_WF_ItemlEAWF_SamplegR(void *p);
   static void deleteArray_WF_ItemlEAWF_SamplegR(void *p);
   static void destruct_WF_ItemlEAWF_SamplegR(void *p);
   static void streamer_WF_ItemlEAWF_SamplegR(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::WF_Item<AWF_Sample>*)
   {
      ::WF_Item<AWF_Sample> *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::WF_Item<AWF_Sample> >(0);
      static ::ROOT::TGenericClassInfo 
         instance("WF_Item<AWF_Sample>", ::WF_Item<AWF_Sample>::Class_Version(), "", 269,
                  typeid(::WF_Item<AWF_Sample>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &WF_ItemlEAWF_SamplegR_Dictionary, isa_proxy, 17,
                  sizeof(::WF_Item<AWF_Sample>) );
      instance.SetNew(&new_WF_ItemlEAWF_SamplegR);
      instance.SetNewArray(&newArray_WF_ItemlEAWF_SamplegR);
      instance.SetDelete(&delete_WF_ItemlEAWF_SamplegR);
      instance.SetDeleteArray(&deleteArray_WF_ItemlEAWF_SamplegR);
      instance.SetDestructor(&destruct_WF_ItemlEAWF_SamplegR);
      instance.SetStreamerFunc(&streamer_WF_ItemlEAWF_SamplegR);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::WF_Item<AWF_Sample>*)
   {
      return GenerateInitInstanceLocal((::WF_Item<AWF_Sample>*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::WF_Item<AWF_Sample>*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *WF_ItemlEAWF_SamplegR_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::WF_Item<AWF_Sample>*)0x0)->GetClass();
      WF_ItemlEAWF_SamplegR_TClassManip(theClass);
   return theClass;
   }

   static void WF_ItemlEAWF_SamplegR_TClassManip(TClass* ){
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *WF_ItemlEDWF_SamplegR_Dictionary();
   static void WF_ItemlEDWF_SamplegR_TClassManip(TClass*);
   static void *new_WF_ItemlEDWF_SamplegR(void *p = 0);
   static void *newArray_WF_ItemlEDWF_SamplegR(Long_t size, void *p);
   static void delete_WF_ItemlEDWF_SamplegR(void *p);
   static void deleteArray_WF_ItemlEDWF_SamplegR(void *p);
   static void destruct_WF_ItemlEDWF_SamplegR(void *p);
   static void streamer_WF_ItemlEDWF_SamplegR(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::WF_Item<DWF_Sample>*)
   {
      ::WF_Item<DWF_Sample> *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::WF_Item<DWF_Sample> >(0);
      static ::ROOT::TGenericClassInfo 
         instance("WF_Item<DWF_Sample>", ::WF_Item<DWF_Sample>::Class_Version(), "", 269,
                  typeid(::WF_Item<DWF_Sample>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &WF_ItemlEDWF_SamplegR_Dictionary, isa_proxy, 17,
                  sizeof(::WF_Item<DWF_Sample>) );
      instance.SetNew(&new_WF_ItemlEDWF_SamplegR);
      instance.SetNewArray(&newArray_WF_ItemlEDWF_SamplegR);
      instance.SetDelete(&delete_WF_ItemlEDWF_SamplegR);
      instance.SetDeleteArray(&deleteArray_WF_ItemlEDWF_SamplegR);
      instance.SetDestructor(&destruct_WF_ItemlEDWF_SamplegR);
      instance.SetStreamerFunc(&streamer_WF_ItemlEDWF_SamplegR);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::WF_Item<DWF_Sample>*)
   {
      return GenerateInitInstanceLocal((::WF_Item<DWF_Sample>*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::WF_Item<DWF_Sample>*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *WF_ItemlEDWF_SamplegR_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::WF_Item<DWF_Sample>*)0x0)->GetClass();
      WF_ItemlEDWF_SamplegR_TClassManip(theClass);
   return theClass;
   }

   static void WF_ItemlEDWF_SamplegR_TClassManip(TClass* ){
   }

} // end of namespace ROOT

namespace ROOT {
   static void *new_AWF_Item(void *p = 0);
   static void *newArray_AWF_Item(Long_t size, void *p);
   static void delete_AWF_Item(void *p);
   static void deleteArray_AWF_Item(void *p);
   static void destruct_AWF_Item(void *p);
   static void streamer_AWF_Item(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::AWF_Item*)
   {
      ::AWF_Item *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::AWF_Item >(0);
      static ::ROOT::TGenericClassInfo 
         instance("AWF_Item", ::AWF_Item::Class_Version(), "", 313,
                  typeid(::AWF_Item), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &::AWF_Item::Dictionary, isa_proxy, 17,
                  sizeof(::AWF_Item) );
      instance.SetNew(&new_AWF_Item);
      instance.SetNewArray(&newArray_AWF_Item);
      instance.SetDelete(&delete_AWF_Item);
      instance.SetDeleteArray(&deleteArray_AWF_Item);
      instance.SetDestructor(&destruct_AWF_Item);
      instance.SetStreamerFunc(&streamer_AWF_Item);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::AWF_Item*)
   {
      return GenerateInitInstanceLocal((::AWF_Item*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::AWF_Item*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
} // end of namespace ROOT

namespace ROOT {
   static void *new_DWF_Item(void *p = 0);
   static void *newArray_DWF_Item(Long_t size, void *p);
   static void delete_DWF_Item(void *p);
   static void deleteArray_DWF_Item(void *p);
   static void destruct_DWF_Item(void *p);
   static void streamer_DWF_Item(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::DWF_Item*)
   {
      ::DWF_Item *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::DWF_Item >(0);
      static ::ROOT::TGenericClassInfo 
         instance("DWF_Item", ::DWF_Item::Class_Version(), "", 330,
                  typeid(::DWF_Item), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &::DWF_Item::Dictionary, isa_proxy, 17,
                  sizeof(::DWF_Item) );
      instance.SetNew(&new_DWF_Item);
      instance.SetNewArray(&newArray_DWF_Item);
      instance.SetDelete(&delete_DWF_Item);
      instance.SetDeleteArray(&deleteArray_DWF_Item);
      instance.SetDestructor(&destruct_DWF_Item);
      instance.SetStreamerFunc(&streamer_DWF_Item);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::DWF_Item*)
   {
      return GenerateInitInstanceLocal((::DWF_Item*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::DWF_Item*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
} // end of namespace ROOT

namespace ROOT {
   static void *new_DaqFramePreamble(void *p = 0);
   static void *newArray_DaqFramePreamble(Long_t size, void *p);
   static void delete_DaqFramePreamble(void *p);
   static void deleteArray_DaqFramePreamble(void *p);
   static void destruct_DaqFramePreamble(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::DaqFramePreamble*)
   {
      ::DaqFramePreamble *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::DaqFramePreamble >(0);
      static ::ROOT::TGenericClassInfo 
         instance("DaqFramePreamble", ::DaqFramePreamble::Class_Version(), "", 526,
                  typeid(::DaqFramePreamble), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &::DaqFramePreamble::Dictionary, isa_proxy, 4,
                  sizeof(::DaqFramePreamble) );
      instance.SetNew(&new_DaqFramePreamble);
      instance.SetNewArray(&newArray_DaqFramePreamble);
      instance.SetDelete(&delete_DaqFramePreamble);
      instance.SetDeleteArray(&deleteArray_DaqFramePreamble);
      instance.SetDestructor(&destruct_DaqFramePreamble);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::DaqFramePreamble*)
   {
      return GenerateInitInstanceLocal((::DaqFramePreamble*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::DaqFramePreamble*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
} // end of namespace ROOT

namespace ROOT {
   static void *new_EventPreamble(void *p = 0);
   static void *newArray_EventPreamble(Long_t size, void *p);
   static void delete_EventPreamble(void *p);
   static void deleteArray_EventPreamble(void *p);
   static void destruct_EventPreamble(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::EventPreamble*)
   {
      ::EventPreamble *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::EventPreamble >(0);
      static ::ROOT::TGenericClassInfo 
         instance("EventPreamble", ::EventPreamble::Class_Version(), "EventPreamble.hh", 17,
                  typeid(::EventPreamble), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &::EventPreamble::Dictionary, isa_proxy, 4,
                  sizeof(::EventPreamble) );
      instance.SetNew(&new_EventPreamble);
      instance.SetNewArray(&newArray_EventPreamble);
      instance.SetDelete(&delete_EventPreamble);
      instance.SetDeleteArray(&deleteArray_EventPreamble);
      instance.SetDestructor(&destruct_EventPreamble);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::EventPreamble*)
   {
      return GenerateInitInstanceLocal((::EventPreamble*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::EventPreamble*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
} // end of namespace ROOT

namespace ROOT {
   static void *new_Summary_Frame(void *p = 0);
   static void *newArray_Summary_Frame(Long_t size, void *p);
   static void delete_Summary_Frame(void *p);
   static void deleteArray_Summary_Frame(void *p);
   static void destruct_Summary_Frame(void *p);
   static void streamer_Summary_Frame(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::Summary_Frame*)
   {
      ::Summary_Frame *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::Summary_Frame >(0);
      static ::ROOT::TGenericClassInfo 
         instance("Summary_Frame", ::Summary_Frame::Class_Version(), "", 702,
                  typeid(::Summary_Frame), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &::Summary_Frame::Dictionary, isa_proxy, 17,
                  sizeof(::Summary_Frame) );
      instance.SetNew(&new_Summary_Frame);
      instance.SetNewArray(&newArray_Summary_Frame);
      instance.SetDelete(&delete_Summary_Frame);
      instance.SetDeleteArray(&deleteArray_Summary_Frame);
      instance.SetDestructor(&destruct_Summary_Frame);
      instance.SetStreamerFunc(&streamer_Summary_Frame);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::Summary_Frame*)
   {
      return GenerateInitInstanceLocal((::Summary_Frame*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::Summary_Frame*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
} // end of namespace ROOT

namespace ROOT {
   static void *new_ExtendedSummary_Frame(void *p = 0);
   static void *newArray_ExtendedSummary_Frame(Long_t size, void *p);
   static void delete_ExtendedSummary_Frame(void *p);
   static void deleteArray_ExtendedSummary_Frame(void *p);
   static void destruct_ExtendedSummary_Frame(void *p);
   static void streamer_ExtendedSummary_Frame(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::ExtendedSummary_Frame*)
   {
      ::ExtendedSummary_Frame *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::ExtendedSummary_Frame >(0);
      static ::ROOT::TGenericClassInfo 
         instance("ExtendedSummary_Frame", ::ExtendedSummary_Frame::Class_Version(), "", 838,
                  typeid(::ExtendedSummary_Frame), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &::ExtendedSummary_Frame::Dictionary, isa_proxy, 17,
                  sizeof(::ExtendedSummary_Frame) );
      instance.SetNew(&new_ExtendedSummary_Frame);
      instance.SetNewArray(&newArray_ExtendedSummary_Frame);
      instance.SetDelete(&delete_ExtendedSummary_Frame);
      instance.SetDeleteArray(&deleteArray_ExtendedSummary_Frame);
      instance.SetDestructor(&destruct_ExtendedSummary_Frame);
      instance.SetStreamerFunc(&streamer_ExtendedSummary_Frame);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::ExtendedSummary_Frame*)
   {
      return GenerateInitInstanceLocal((::ExtendedSummary_Frame*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::ExtendedSummary_Frame*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
} // end of namespace ROOT

namespace ROOT {
   static TClass *FramelEStatus_ItemgR_Dictionary();
   static void FramelEStatus_ItemgR_TClassManip(TClass*);
   static void *new_FramelEStatus_ItemgR(void *p = 0);
   static void *newArray_FramelEStatus_ItemgR(Long_t size, void *p);
   static void delete_FramelEStatus_ItemgR(void *p);
   static void deleteArray_FramelEStatus_ItemgR(void *p);
   static void destruct_FramelEStatus_ItemgR(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::Frame<Status_Item>*)
   {
      ::Frame<Status_Item> *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::Frame<Status_Item> >(0);
      static ::ROOT::TGenericClassInfo 
         instance("Frame<Status_Item>", ::Frame<Status_Item>::Class_Version(), "", 906,
                  typeid(::Frame<Status_Item>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &FramelEStatus_ItemgR_Dictionary, isa_proxy, 4,
                  sizeof(::Frame<Status_Item>) );
      instance.SetNew(&new_FramelEStatus_ItemgR);
      instance.SetNewArray(&newArray_FramelEStatus_ItemgR);
      instance.SetDelete(&delete_FramelEStatus_ItemgR);
      instance.SetDeleteArray(&deleteArray_FramelEStatus_ItemgR);
      instance.SetDestructor(&destruct_FramelEStatus_ItemgR);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::Frame<Status_Item>*)
   {
      return GenerateInitInstanceLocal((::Frame<Status_Item>*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::Frame<Status_Item>*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *FramelEStatus_ItemgR_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::Frame<Status_Item>*)0x0)->GetClass();
      FramelEStatus_ItemgR_TClassManip(theClass);
   return theClass;
   }

   static void FramelEStatus_ItemgR_TClassManip(TClass* ){
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *FramelERTS_ItemgR_Dictionary();
   static void FramelERTS_ItemgR_TClassManip(TClass*);
   static void *new_FramelERTS_ItemgR(void *p = 0);
   static void *newArray_FramelERTS_ItemgR(Long_t size, void *p);
   static void delete_FramelERTS_ItemgR(void *p);
   static void deleteArray_FramelERTS_ItemgR(void *p);
   static void destruct_FramelERTS_ItemgR(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::Frame<RTS_Item>*)
   {
      ::Frame<RTS_Item> *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::Frame<RTS_Item> >(0);
      static ::ROOT::TGenericClassInfo 
         instance("Frame<RTS_Item>", ::Frame<RTS_Item>::Class_Version(), "", 906,
                  typeid(::Frame<RTS_Item>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &FramelERTS_ItemgR_Dictionary, isa_proxy, 4,
                  sizeof(::Frame<RTS_Item>) );
      instance.SetNew(&new_FramelERTS_ItemgR);
      instance.SetNewArray(&newArray_FramelERTS_ItemgR);
      instance.SetDelete(&delete_FramelERTS_ItemgR);
      instance.SetDeleteArray(&deleteArray_FramelERTS_ItemgR);
      instance.SetDestructor(&destruct_FramelERTS_ItemgR);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::Frame<RTS_Item>*)
   {
      return GenerateInitInstanceLocal((::Frame<RTS_Item>*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::Frame<RTS_Item>*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *FramelERTS_ItemgR_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::Frame<RTS_Item>*)0x0)->GetClass();
      FramelERTS_ItemgR_TClassManip(theClass);
   return theClass;
   }

   static void FramelERTS_ItemgR_TClassManip(TClass* ){
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *FramelECRM_ItemgR_Dictionary();
   static void FramelECRM_ItemgR_TClassManip(TClass*);
   static void *new_FramelECRM_ItemgR(void *p = 0);
   static void *newArray_FramelECRM_ItemgR(Long_t size, void *p);
   static void delete_FramelECRM_ItemgR(void *p);
   static void deleteArray_FramelECRM_ItemgR(void *p);
   static void destruct_FramelECRM_ItemgR(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::Frame<CRM_Item>*)
   {
      ::Frame<CRM_Item> *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::Frame<CRM_Item> >(0);
      static ::ROOT::TGenericClassInfo 
         instance("Frame<CRM_Item>", ::Frame<CRM_Item>::Class_Version(), "", 906,
                  typeid(::Frame<CRM_Item>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &FramelECRM_ItemgR_Dictionary, isa_proxy, 4,
                  sizeof(::Frame<CRM_Item>) );
      instance.SetNew(&new_FramelECRM_ItemgR);
      instance.SetNewArray(&newArray_FramelECRM_ItemgR);
      instance.SetDelete(&delete_FramelECRM_ItemgR);
      instance.SetDeleteArray(&deleteArray_FramelECRM_ItemgR);
      instance.SetDestructor(&destruct_FramelECRM_ItemgR);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::Frame<CRM_Item>*)
   {
      return GenerateInitInstanceLocal((::Frame<CRM_Item>*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::Frame<CRM_Item>*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *FramelECRM_ItemgR_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::Frame<CRM_Item>*)0x0)->GetClass();
      FramelECRM_ItemgR_TClassManip(theClass);
   return theClass;
   }

   static void FramelECRM_ItemgR_TClassManip(TClass* ){
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *FramelESPE_ItemgR_Dictionary();
   static void FramelESPE_ItemgR_TClassManip(TClass*);
   static void *new_FramelESPE_ItemgR(void *p = 0);
   static void *newArray_FramelESPE_ItemgR(Long_t size, void *p);
   static void delete_FramelESPE_ItemgR(void *p);
   static void deleteArray_FramelESPE_ItemgR(void *p);
   static void destruct_FramelESPE_ItemgR(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::Frame<SPE_Item>*)
   {
      ::Frame<SPE_Item> *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::Frame<SPE_Item> >(0);
      static ::ROOT::TGenericClassInfo 
         instance("Frame<SPE_Item>", ::Frame<SPE_Item>::Class_Version(), "", 906,
                  typeid(::Frame<SPE_Item>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &FramelESPE_ItemgR_Dictionary, isa_proxy, 4,
                  sizeof(::Frame<SPE_Item>) );
      instance.SetNew(&new_FramelESPE_ItemgR);
      instance.SetNewArray(&newArray_FramelESPE_ItemgR);
      instance.SetDelete(&delete_FramelESPE_ItemgR);
      instance.SetDeleteArray(&deleteArray_FramelESPE_ItemgR);
      instance.SetDestructor(&destruct_FramelESPE_ItemgR);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::Frame<SPE_Item>*)
   {
      return GenerateInitInstanceLocal((::Frame<SPE_Item>*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::Frame<SPE_Item>*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *FramelESPE_ItemgR_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::Frame<SPE_Item>*)0x0)->GetClass();
      FramelESPE_ItemgR_TClassManip(theClass);
   return theClass;
   }

   static void FramelESPE_ItemgR_TClassManip(TClass* ){
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *FramelEAWF_ItemgR_Dictionary();
   static void FramelEAWF_ItemgR_TClassManip(TClass*);
   static void *new_FramelEAWF_ItemgR(void *p = 0);
   static void *newArray_FramelEAWF_ItemgR(Long_t size, void *p);
   static void delete_FramelEAWF_ItemgR(void *p);
   static void deleteArray_FramelEAWF_ItemgR(void *p);
   static void destruct_FramelEAWF_ItemgR(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::Frame<AWF_Item>*)
   {
      ::Frame<AWF_Item> *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::Frame<AWF_Item> >(0);
      static ::ROOT::TGenericClassInfo 
         instance("Frame<AWF_Item>", ::Frame<AWF_Item>::Class_Version(), "", 906,
                  typeid(::Frame<AWF_Item>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &FramelEAWF_ItemgR_Dictionary, isa_proxy, 4,
                  sizeof(::Frame<AWF_Item>) );
      instance.SetNew(&new_FramelEAWF_ItemgR);
      instance.SetNewArray(&newArray_FramelEAWF_ItemgR);
      instance.SetDelete(&delete_FramelEAWF_ItemgR);
      instance.SetDeleteArray(&deleteArray_FramelEAWF_ItemgR);
      instance.SetDestructor(&destruct_FramelEAWF_ItemgR);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::Frame<AWF_Item>*)
   {
      return GenerateInitInstanceLocal((::Frame<AWF_Item>*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::Frame<AWF_Item>*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *FramelEAWF_ItemgR_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::Frame<AWF_Item>*)0x0)->GetClass();
      FramelEAWF_ItemgR_TClassManip(theClass);
   return theClass;
   }

   static void FramelEAWF_ItemgR_TClassManip(TClass* ){
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *FramelEDWF_ItemgR_Dictionary();
   static void FramelEDWF_ItemgR_TClassManip(TClass*);
   static void *new_FramelEDWF_ItemgR(void *p = 0);
   static void *newArray_FramelEDWF_ItemgR(Long_t size, void *p);
   static void delete_FramelEDWF_ItemgR(void *p);
   static void deleteArray_FramelEDWF_ItemgR(void *p);
   static void destruct_FramelEDWF_ItemgR(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::Frame<DWF_Item>*)
   {
      ::Frame<DWF_Item> *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::Frame<DWF_Item> >(0);
      static ::ROOT::TGenericClassInfo 
         instance("Frame<DWF_Item>", ::Frame<DWF_Item>::Class_Version(), "", 906,
                  typeid(::Frame<DWF_Item>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &FramelEDWF_ItemgR_Dictionary, isa_proxy, 4,
                  sizeof(::Frame<DWF_Item>) );
      instance.SetNew(&new_FramelEDWF_ItemgR);
      instance.SetNewArray(&newArray_FramelEDWF_ItemgR);
      instance.SetDelete(&delete_FramelEDWF_ItemgR);
      instance.SetDeleteArray(&deleteArray_FramelEDWF_ItemgR);
      instance.SetDestructor(&destruct_FramelEDWF_ItemgR);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::Frame<DWF_Item>*)
   {
      return GenerateInitInstanceLocal((::Frame<DWF_Item>*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::Frame<DWF_Item>*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *FramelEDWF_ItemgR_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::Frame<DWF_Item>*)0x0)->GetClass();
      FramelEDWF_ItemgR_TClassManip(theClass);
   return theClass;
   }

   static void FramelEDWF_ItemgR_TClassManip(TClass* ){
   }

} // end of namespace ROOT

namespace ROOT {
   static void *new_Status_Frame(void *p = 0);
   static void *newArray_Status_Frame(Long_t size, void *p);
   static void delete_Status_Frame(void *p);
   static void deleteArray_Status_Frame(void *p);
   static void destruct_Status_Frame(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::Status_Frame*)
   {
      ::Status_Frame *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::Status_Frame >(0);
      static ::ROOT::TGenericClassInfo 
         instance("Status_Frame", ::Status_Frame::Class_Version(), "", 975,
                  typeid(::Status_Frame), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &::Status_Frame::Dictionary, isa_proxy, 4,
                  sizeof(::Status_Frame) );
      instance.SetNew(&new_Status_Frame);
      instance.SetNewArray(&newArray_Status_Frame);
      instance.SetDelete(&delete_Status_Frame);
      instance.SetDeleteArray(&deleteArray_Status_Frame);
      instance.SetDestructor(&destruct_Status_Frame);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::Status_Frame*)
   {
      return GenerateInitInstanceLocal((::Status_Frame*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::Status_Frame*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
} // end of namespace ROOT

namespace ROOT {
   static void *new_RTS_Frame(void *p = 0);
   static void *newArray_RTS_Frame(Long_t size, void *p);
   static void delete_RTS_Frame(void *p);
   static void deleteArray_RTS_Frame(void *p);
   static void destruct_RTS_Frame(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::RTS_Frame*)
   {
      ::RTS_Frame *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::RTS_Frame >(0);
      static ::ROOT::TGenericClassInfo 
         instance("RTS_Frame", ::RTS_Frame::Class_Version(), "", 992,
                  typeid(::RTS_Frame), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &::RTS_Frame::Dictionary, isa_proxy, 4,
                  sizeof(::RTS_Frame) );
      instance.SetNew(&new_RTS_Frame);
      instance.SetNewArray(&newArray_RTS_Frame);
      instance.SetDelete(&delete_RTS_Frame);
      instance.SetDeleteArray(&deleteArray_RTS_Frame);
      instance.SetDestructor(&destruct_RTS_Frame);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::RTS_Frame*)
   {
      return GenerateInitInstanceLocal((::RTS_Frame*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::RTS_Frame*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
} // end of namespace ROOT

namespace ROOT {
   static void *new_CRM_Frame(void *p = 0);
   static void *newArray_CRM_Frame(Long_t size, void *p);
   static void delete_CRM_Frame(void *p);
   static void deleteArray_CRM_Frame(void *p);
   static void destruct_CRM_Frame(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::CRM_Frame*)
   {
      ::CRM_Frame *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::CRM_Frame >(0);
      static ::ROOT::TGenericClassInfo 
         instance("CRM_Frame", ::CRM_Frame::Class_Version(), "", 1009,
                  typeid(::CRM_Frame), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &::CRM_Frame::Dictionary, isa_proxy, 4,
                  sizeof(::CRM_Frame) );
      instance.SetNew(&new_CRM_Frame);
      instance.SetNewArray(&newArray_CRM_Frame);
      instance.SetDelete(&delete_CRM_Frame);
      instance.SetDeleteArray(&deleteArray_CRM_Frame);
      instance.SetDestructor(&destruct_CRM_Frame);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::CRM_Frame*)
   {
      return GenerateInitInstanceLocal((::CRM_Frame*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::CRM_Frame*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
} // end of namespace ROOT

namespace ROOT {
   static void *new_SPE_Frame(void *p = 0);
   static void *newArray_SPE_Frame(Long_t size, void *p);
   static void delete_SPE_Frame(void *p);
   static void deleteArray_SPE_Frame(void *p);
   static void destruct_SPE_Frame(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::SPE_Frame*)
   {
      ::SPE_Frame *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::SPE_Frame >(0);
      static ::ROOT::TGenericClassInfo 
         instance("SPE_Frame", ::SPE_Frame::Class_Version(), "", 1026,
                  typeid(::SPE_Frame), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &::SPE_Frame::Dictionary, isa_proxy, 4,
                  sizeof(::SPE_Frame) );
      instance.SetNew(&new_SPE_Frame);
      instance.SetNewArray(&newArray_SPE_Frame);
      instance.SetDelete(&delete_SPE_Frame);
      instance.SetDeleteArray(&deleteArray_SPE_Frame);
      instance.SetDestructor(&destruct_SPE_Frame);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::SPE_Frame*)
   {
      return GenerateInitInstanceLocal((::SPE_Frame*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::SPE_Frame*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
} // end of namespace ROOT

namespace ROOT {
   static void *new_AWF_Frame(void *p = 0);
   static void *newArray_AWF_Frame(Long_t size, void *p);
   static void delete_AWF_Frame(void *p);
   static void deleteArray_AWF_Frame(void *p);
   static void destruct_AWF_Frame(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::AWF_Frame*)
   {
      ::AWF_Frame *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::AWF_Frame >(0);
      static ::ROOT::TGenericClassInfo 
         instance("AWF_Frame", ::AWF_Frame::Class_Version(), "", 1043,
                  typeid(::AWF_Frame), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &::AWF_Frame::Dictionary, isa_proxy, 4,
                  sizeof(::AWF_Frame) );
      instance.SetNew(&new_AWF_Frame);
      instance.SetNewArray(&newArray_AWF_Frame);
      instance.SetDelete(&delete_AWF_Frame);
      instance.SetDeleteArray(&deleteArray_AWF_Frame);
      instance.SetDestructor(&destruct_AWF_Frame);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::AWF_Frame*)
   {
      return GenerateInitInstanceLocal((::AWF_Frame*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::AWF_Frame*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
} // end of namespace ROOT

namespace ROOT {
   static void *new_DWF_Frame(void *p = 0);
   static void *newArray_DWF_Frame(Long_t size, void *p);
   static void delete_DWF_Frame(void *p);
   static void deleteArray_DWF_Frame(void *p);
   static void destruct_DWF_Frame(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::DWF_Frame*)
   {
      ::DWF_Frame *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::DWF_Frame >(0);
      static ::ROOT::TGenericClassInfo 
         instance("DWF_Frame", ::DWF_Frame::Class_Version(), "", 1060,
                  typeid(::DWF_Frame), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &::DWF_Frame::Dictionary, isa_proxy, 4,
                  sizeof(::DWF_Frame) );
      instance.SetNew(&new_DWF_Frame);
      instance.SetNewArray(&newArray_DWF_Frame);
      instance.SetDelete(&delete_DWF_Frame);
      instance.SetDeleteArray(&deleteArray_DWF_Frame);
      instance.SetDestructor(&destruct_DWF_Frame);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::DWF_Frame*)
   {
      return GenerateInitInstanceLocal((::DWF_Frame*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::DWF_Frame*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
} // end of namespace ROOT

namespace ROOT {
   static TClass *TimeSlicelEStatus_FramegR_Dictionary();
   static void TimeSlicelEStatus_FramegR_TClassManip(TClass*);
   static void *new_TimeSlicelEStatus_FramegR(void *p = 0);
   static void *newArray_TimeSlicelEStatus_FramegR(Long_t size, void *p);
   static void delete_TimeSlicelEStatus_FramegR(void *p);
   static void deleteArray_TimeSlicelEStatus_FramegR(void *p);
   static void destruct_TimeSlicelEStatus_FramegR(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TimeSlice<Status_Frame>*)
   {
      ::TimeSlice<Status_Frame> *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TimeSlice<Status_Frame> >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TimeSlice<Status_Frame>", ::TimeSlice<Status_Frame>::Class_Version(), "", 1077,
                  typeid(::TimeSlice<Status_Frame>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &TimeSlicelEStatus_FramegR_Dictionary, isa_proxy, 4,
                  sizeof(::TimeSlice<Status_Frame>) );
      instance.SetNew(&new_TimeSlicelEStatus_FramegR);
      instance.SetNewArray(&newArray_TimeSlicelEStatus_FramegR);
      instance.SetDelete(&delete_TimeSlicelEStatus_FramegR);
      instance.SetDeleteArray(&deleteArray_TimeSlicelEStatus_FramegR);
      instance.SetDestructor(&destruct_TimeSlicelEStatus_FramegR);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TimeSlice<Status_Frame>*)
   {
      return GenerateInitInstanceLocal((::TimeSlice<Status_Frame>*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::TimeSlice<Status_Frame>*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *TimeSlicelEStatus_FramegR_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::TimeSlice<Status_Frame>*)0x0)->GetClass();
      TimeSlicelEStatus_FramegR_TClassManip(theClass);
   return theClass;
   }

   static void TimeSlicelEStatus_FramegR_TClassManip(TClass* ){
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *TimeSlicelERTS_FramegR_Dictionary();
   static void TimeSlicelERTS_FramegR_TClassManip(TClass*);
   static void *new_TimeSlicelERTS_FramegR(void *p = 0);
   static void *newArray_TimeSlicelERTS_FramegR(Long_t size, void *p);
   static void delete_TimeSlicelERTS_FramegR(void *p);
   static void deleteArray_TimeSlicelERTS_FramegR(void *p);
   static void destruct_TimeSlicelERTS_FramegR(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TimeSlice<RTS_Frame>*)
   {
      ::TimeSlice<RTS_Frame> *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TimeSlice<RTS_Frame> >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TimeSlice<RTS_Frame>", ::TimeSlice<RTS_Frame>::Class_Version(), "", 1077,
                  typeid(::TimeSlice<RTS_Frame>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &TimeSlicelERTS_FramegR_Dictionary, isa_proxy, 4,
                  sizeof(::TimeSlice<RTS_Frame>) );
      instance.SetNew(&new_TimeSlicelERTS_FramegR);
      instance.SetNewArray(&newArray_TimeSlicelERTS_FramegR);
      instance.SetDelete(&delete_TimeSlicelERTS_FramegR);
      instance.SetDeleteArray(&deleteArray_TimeSlicelERTS_FramegR);
      instance.SetDestructor(&destruct_TimeSlicelERTS_FramegR);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TimeSlice<RTS_Frame>*)
   {
      return GenerateInitInstanceLocal((::TimeSlice<RTS_Frame>*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::TimeSlice<RTS_Frame>*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *TimeSlicelERTS_FramegR_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::TimeSlice<RTS_Frame>*)0x0)->GetClass();
      TimeSlicelERTS_FramegR_TClassManip(theClass);
   return theClass;
   }

   static void TimeSlicelERTS_FramegR_TClassManip(TClass* ){
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *TimeSlicelECRM_FramegR_Dictionary();
   static void TimeSlicelECRM_FramegR_TClassManip(TClass*);
   static void *new_TimeSlicelECRM_FramegR(void *p = 0);
   static void *newArray_TimeSlicelECRM_FramegR(Long_t size, void *p);
   static void delete_TimeSlicelECRM_FramegR(void *p);
   static void deleteArray_TimeSlicelECRM_FramegR(void *p);
   static void destruct_TimeSlicelECRM_FramegR(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TimeSlice<CRM_Frame>*)
   {
      ::TimeSlice<CRM_Frame> *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TimeSlice<CRM_Frame> >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TimeSlice<CRM_Frame>", ::TimeSlice<CRM_Frame>::Class_Version(), "", 1077,
                  typeid(::TimeSlice<CRM_Frame>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &TimeSlicelECRM_FramegR_Dictionary, isa_proxy, 4,
                  sizeof(::TimeSlice<CRM_Frame>) );
      instance.SetNew(&new_TimeSlicelECRM_FramegR);
      instance.SetNewArray(&newArray_TimeSlicelECRM_FramegR);
      instance.SetDelete(&delete_TimeSlicelECRM_FramegR);
      instance.SetDeleteArray(&deleteArray_TimeSlicelECRM_FramegR);
      instance.SetDestructor(&destruct_TimeSlicelECRM_FramegR);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TimeSlice<CRM_Frame>*)
   {
      return GenerateInitInstanceLocal((::TimeSlice<CRM_Frame>*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::TimeSlice<CRM_Frame>*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *TimeSlicelECRM_FramegR_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::TimeSlice<CRM_Frame>*)0x0)->GetClass();
      TimeSlicelECRM_FramegR_TClassManip(theClass);
   return theClass;
   }

   static void TimeSlicelECRM_FramegR_TClassManip(TClass* ){
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *TimeSlicelESPE_FramegR_Dictionary();
   static void TimeSlicelESPE_FramegR_TClassManip(TClass*);
   static void *new_TimeSlicelESPE_FramegR(void *p = 0);
   static void *newArray_TimeSlicelESPE_FramegR(Long_t size, void *p);
   static void delete_TimeSlicelESPE_FramegR(void *p);
   static void deleteArray_TimeSlicelESPE_FramegR(void *p);
   static void destruct_TimeSlicelESPE_FramegR(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TimeSlice<SPE_Frame>*)
   {
      ::TimeSlice<SPE_Frame> *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TimeSlice<SPE_Frame> >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TimeSlice<SPE_Frame>", ::TimeSlice<SPE_Frame>::Class_Version(), "", 1077,
                  typeid(::TimeSlice<SPE_Frame>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &TimeSlicelESPE_FramegR_Dictionary, isa_proxy, 4,
                  sizeof(::TimeSlice<SPE_Frame>) );
      instance.SetNew(&new_TimeSlicelESPE_FramegR);
      instance.SetNewArray(&newArray_TimeSlicelESPE_FramegR);
      instance.SetDelete(&delete_TimeSlicelESPE_FramegR);
      instance.SetDeleteArray(&deleteArray_TimeSlicelESPE_FramegR);
      instance.SetDestructor(&destruct_TimeSlicelESPE_FramegR);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TimeSlice<SPE_Frame>*)
   {
      return GenerateInitInstanceLocal((::TimeSlice<SPE_Frame>*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::TimeSlice<SPE_Frame>*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *TimeSlicelESPE_FramegR_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::TimeSlice<SPE_Frame>*)0x0)->GetClass();
      TimeSlicelESPE_FramegR_TClassManip(theClass);
   return theClass;
   }

   static void TimeSlicelESPE_FramegR_TClassManip(TClass* ){
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *TimeSlicelEAWF_FramegR_Dictionary();
   static void TimeSlicelEAWF_FramegR_TClassManip(TClass*);
   static void *new_TimeSlicelEAWF_FramegR(void *p = 0);
   static void *newArray_TimeSlicelEAWF_FramegR(Long_t size, void *p);
   static void delete_TimeSlicelEAWF_FramegR(void *p);
   static void deleteArray_TimeSlicelEAWF_FramegR(void *p);
   static void destruct_TimeSlicelEAWF_FramegR(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TimeSlice<AWF_Frame>*)
   {
      ::TimeSlice<AWF_Frame> *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TimeSlice<AWF_Frame> >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TimeSlice<AWF_Frame>", ::TimeSlice<AWF_Frame>::Class_Version(), "", 1077,
                  typeid(::TimeSlice<AWF_Frame>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &TimeSlicelEAWF_FramegR_Dictionary, isa_proxy, 4,
                  sizeof(::TimeSlice<AWF_Frame>) );
      instance.SetNew(&new_TimeSlicelEAWF_FramegR);
      instance.SetNewArray(&newArray_TimeSlicelEAWF_FramegR);
      instance.SetDelete(&delete_TimeSlicelEAWF_FramegR);
      instance.SetDeleteArray(&deleteArray_TimeSlicelEAWF_FramegR);
      instance.SetDestructor(&destruct_TimeSlicelEAWF_FramegR);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TimeSlice<AWF_Frame>*)
   {
      return GenerateInitInstanceLocal((::TimeSlice<AWF_Frame>*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::TimeSlice<AWF_Frame>*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *TimeSlicelEAWF_FramegR_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::TimeSlice<AWF_Frame>*)0x0)->GetClass();
      TimeSlicelEAWF_FramegR_TClassManip(theClass);
   return theClass;
   }

   static void TimeSlicelEAWF_FramegR_TClassManip(TClass* ){
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *TimeSlicelEDWF_FramegR_Dictionary();
   static void TimeSlicelEDWF_FramegR_TClassManip(TClass*);
   static void *new_TimeSlicelEDWF_FramegR(void *p = 0);
   static void *newArray_TimeSlicelEDWF_FramegR(Long_t size, void *p);
   static void delete_TimeSlicelEDWF_FramegR(void *p);
   static void deleteArray_TimeSlicelEDWF_FramegR(void *p);
   static void destruct_TimeSlicelEDWF_FramegR(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TimeSlice<DWF_Frame>*)
   {
      ::TimeSlice<DWF_Frame> *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TimeSlice<DWF_Frame> >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TimeSlice<DWF_Frame>", ::TimeSlice<DWF_Frame>::Class_Version(), "", 1077,
                  typeid(::TimeSlice<DWF_Frame>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &TimeSlicelEDWF_FramegR_Dictionary, isa_proxy, 4,
                  sizeof(::TimeSlice<DWF_Frame>) );
      instance.SetNew(&new_TimeSlicelEDWF_FramegR);
      instance.SetNewArray(&newArray_TimeSlicelEDWF_FramegR);
      instance.SetDelete(&delete_TimeSlicelEDWF_FramegR);
      instance.SetDeleteArray(&deleteArray_TimeSlicelEDWF_FramegR);
      instance.SetDestructor(&destruct_TimeSlicelEDWF_FramegR);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TimeSlice<DWF_Frame>*)
   {
      return GenerateInitInstanceLocal((::TimeSlice<DWF_Frame>*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::TimeSlice<DWF_Frame>*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *TimeSlicelEDWF_FramegR_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::TimeSlice<DWF_Frame>*)0x0)->GetClass();
      TimeSlicelEDWF_FramegR_TClassManip(theClass);
   return theClass;
   }

   static void TimeSlicelEDWF_FramegR_TClassManip(TClass* ){
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *TimeSlicelESummary_FramegR_Dictionary();
   static void TimeSlicelESummary_FramegR_TClassManip(TClass*);
   static void *new_TimeSlicelESummary_FramegR(void *p = 0);
   static void *newArray_TimeSlicelESummary_FramegR(Long_t size, void *p);
   static void delete_TimeSlicelESummary_FramegR(void *p);
   static void deleteArray_TimeSlicelESummary_FramegR(void *p);
   static void destruct_TimeSlicelESummary_FramegR(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TimeSlice<Summary_Frame>*)
   {
      ::TimeSlice<Summary_Frame> *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TimeSlice<Summary_Frame> >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TimeSlice<Summary_Frame>", ::TimeSlice<Summary_Frame>::Class_Version(), "", 1077,
                  typeid(::TimeSlice<Summary_Frame>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &TimeSlicelESummary_FramegR_Dictionary, isa_proxy, 4,
                  sizeof(::TimeSlice<Summary_Frame>) );
      instance.SetNew(&new_TimeSlicelESummary_FramegR);
      instance.SetNewArray(&newArray_TimeSlicelESummary_FramegR);
      instance.SetDelete(&delete_TimeSlicelESummary_FramegR);
      instance.SetDeleteArray(&deleteArray_TimeSlicelESummary_FramegR);
      instance.SetDestructor(&destruct_TimeSlicelESummary_FramegR);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TimeSlice<Summary_Frame>*)
   {
      return GenerateInitInstanceLocal((::TimeSlice<Summary_Frame>*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::TimeSlice<Summary_Frame>*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *TimeSlicelESummary_FramegR_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::TimeSlice<Summary_Frame>*)0x0)->GetClass();
      TimeSlicelESummary_FramegR_TClassManip(theClass);
   return theClass;
   }

   static void TimeSlicelESummary_FramegR_TClassManip(TClass* ){
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *TimeSlicelEExtendedSummary_FramegR_Dictionary();
   static void TimeSlicelEExtendedSummary_FramegR_TClassManip(TClass*);
   static void *new_TimeSlicelEExtendedSummary_FramegR(void *p = 0);
   static void *newArray_TimeSlicelEExtendedSummary_FramegR(Long_t size, void *p);
   static void delete_TimeSlicelEExtendedSummary_FramegR(void *p);
   static void deleteArray_TimeSlicelEExtendedSummary_FramegR(void *p);
   static void destruct_TimeSlicelEExtendedSummary_FramegR(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TimeSlice<ExtendedSummary_Frame>*)
   {
      ::TimeSlice<ExtendedSummary_Frame> *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TimeSlice<ExtendedSummary_Frame> >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TimeSlice<ExtendedSummary_Frame>", ::TimeSlice<ExtendedSummary_Frame>::Class_Version(), "", 1077,
                  typeid(::TimeSlice<ExtendedSummary_Frame>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &TimeSlicelEExtendedSummary_FramegR_Dictionary, isa_proxy, 4,
                  sizeof(::TimeSlice<ExtendedSummary_Frame>) );
      instance.SetNew(&new_TimeSlicelEExtendedSummary_FramegR);
      instance.SetNewArray(&newArray_TimeSlicelEExtendedSummary_FramegR);
      instance.SetDelete(&delete_TimeSlicelEExtendedSummary_FramegR);
      instance.SetDeleteArray(&deleteArray_TimeSlicelEExtendedSummary_FramegR);
      instance.SetDestructor(&destruct_TimeSlicelEExtendedSummary_FramegR);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TimeSlice<ExtendedSummary_Frame>*)
   {
      return GenerateInitInstanceLocal((::TimeSlice<ExtendedSummary_Frame>*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::TimeSlice<ExtendedSummary_Frame>*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *TimeSlicelEExtendedSummary_FramegR_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::TimeSlice<ExtendedSummary_Frame>*)0x0)->GetClass();
      TimeSlicelEExtendedSummary_FramegR_TClassManip(theClass);
   return theClass;
   }

   static void TimeSlicelEExtendedSummary_FramegR_TClassManip(TClass* ){
   }

} // end of namespace ROOT

namespace ROOT {
   static void *new_Status_TimeSlice(void *p = 0);
   static void *newArray_Status_TimeSlice(Long_t size, void *p);
   static void delete_Status_TimeSlice(void *p);
   static void deleteArray_Status_TimeSlice(void *p);
   static void destruct_Status_TimeSlice(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::Status_TimeSlice*)
   {
      ::Status_TimeSlice *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::Status_TimeSlice >(0);
      static ::ROOT::TGenericClassInfo 
         instance("Status_TimeSlice", ::Status_TimeSlice::Class_Version(), "", 1166,
                  typeid(::Status_TimeSlice), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &::Status_TimeSlice::Dictionary, isa_proxy, 4,
                  sizeof(::Status_TimeSlice) );
      instance.SetNew(&new_Status_TimeSlice);
      instance.SetNewArray(&newArray_Status_TimeSlice);
      instance.SetDelete(&delete_Status_TimeSlice);
      instance.SetDeleteArray(&deleteArray_Status_TimeSlice);
      instance.SetDestructor(&destruct_Status_TimeSlice);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::Status_TimeSlice*)
   {
      return GenerateInitInstanceLocal((::Status_TimeSlice*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::Status_TimeSlice*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
} // end of namespace ROOT

namespace ROOT {
   static void *new_RTS_TimeSlice(void *p = 0);
   static void *newArray_RTS_TimeSlice(Long_t size, void *p);
   static void delete_RTS_TimeSlice(void *p);
   static void deleteArray_RTS_TimeSlice(void *p);
   static void destruct_RTS_TimeSlice(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::RTS_TimeSlice*)
   {
      ::RTS_TimeSlice *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::RTS_TimeSlice >(0);
      static ::ROOT::TGenericClassInfo 
         instance("RTS_TimeSlice", ::RTS_TimeSlice::Class_Version(), "", 1183,
                  typeid(::RTS_TimeSlice), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &::RTS_TimeSlice::Dictionary, isa_proxy, 4,
                  sizeof(::RTS_TimeSlice) );
      instance.SetNew(&new_RTS_TimeSlice);
      instance.SetNewArray(&newArray_RTS_TimeSlice);
      instance.SetDelete(&delete_RTS_TimeSlice);
      instance.SetDeleteArray(&deleteArray_RTS_TimeSlice);
      instance.SetDestructor(&destruct_RTS_TimeSlice);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::RTS_TimeSlice*)
   {
      return GenerateInitInstanceLocal((::RTS_TimeSlice*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::RTS_TimeSlice*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
} // end of namespace ROOT

namespace ROOT {
   static void *new_CRM_TimeSlice(void *p = 0);
   static void *newArray_CRM_TimeSlice(Long_t size, void *p);
   static void delete_CRM_TimeSlice(void *p);
   static void deleteArray_CRM_TimeSlice(void *p);
   static void destruct_CRM_TimeSlice(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::CRM_TimeSlice*)
   {
      ::CRM_TimeSlice *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::CRM_TimeSlice >(0);
      static ::ROOT::TGenericClassInfo 
         instance("CRM_TimeSlice", ::CRM_TimeSlice::Class_Version(), "", 1200,
                  typeid(::CRM_TimeSlice), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &::CRM_TimeSlice::Dictionary, isa_proxy, 4,
                  sizeof(::CRM_TimeSlice) );
      instance.SetNew(&new_CRM_TimeSlice);
      instance.SetNewArray(&newArray_CRM_TimeSlice);
      instance.SetDelete(&delete_CRM_TimeSlice);
      instance.SetDeleteArray(&deleteArray_CRM_TimeSlice);
      instance.SetDestructor(&destruct_CRM_TimeSlice);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::CRM_TimeSlice*)
   {
      return GenerateInitInstanceLocal((::CRM_TimeSlice*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::CRM_TimeSlice*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
} // end of namespace ROOT

namespace ROOT {
   static void *new_SPE_TimeSlice(void *p = 0);
   static void *newArray_SPE_TimeSlice(Long_t size, void *p);
   static void delete_SPE_TimeSlice(void *p);
   static void deleteArray_SPE_TimeSlice(void *p);
   static void destruct_SPE_TimeSlice(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::SPE_TimeSlice*)
   {
      ::SPE_TimeSlice *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::SPE_TimeSlice >(0);
      static ::ROOT::TGenericClassInfo 
         instance("SPE_TimeSlice", ::SPE_TimeSlice::Class_Version(), "", 1217,
                  typeid(::SPE_TimeSlice), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &::SPE_TimeSlice::Dictionary, isa_proxy, 4,
                  sizeof(::SPE_TimeSlice) );
      instance.SetNew(&new_SPE_TimeSlice);
      instance.SetNewArray(&newArray_SPE_TimeSlice);
      instance.SetDelete(&delete_SPE_TimeSlice);
      instance.SetDeleteArray(&deleteArray_SPE_TimeSlice);
      instance.SetDestructor(&destruct_SPE_TimeSlice);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::SPE_TimeSlice*)
   {
      return GenerateInitInstanceLocal((::SPE_TimeSlice*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::SPE_TimeSlice*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
} // end of namespace ROOT

namespace ROOT {
   static void *new_AWF_TimeSlice(void *p = 0);
   static void *newArray_AWF_TimeSlice(Long_t size, void *p);
   static void delete_AWF_TimeSlice(void *p);
   static void deleteArray_AWF_TimeSlice(void *p);
   static void destruct_AWF_TimeSlice(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::AWF_TimeSlice*)
   {
      ::AWF_TimeSlice *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::AWF_TimeSlice >(0);
      static ::ROOT::TGenericClassInfo 
         instance("AWF_TimeSlice", ::AWF_TimeSlice::Class_Version(), "", 1234,
                  typeid(::AWF_TimeSlice), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &::AWF_TimeSlice::Dictionary, isa_proxy, 4,
                  sizeof(::AWF_TimeSlice) );
      instance.SetNew(&new_AWF_TimeSlice);
      instance.SetNewArray(&newArray_AWF_TimeSlice);
      instance.SetDelete(&delete_AWF_TimeSlice);
      instance.SetDeleteArray(&deleteArray_AWF_TimeSlice);
      instance.SetDestructor(&destruct_AWF_TimeSlice);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::AWF_TimeSlice*)
   {
      return GenerateInitInstanceLocal((::AWF_TimeSlice*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::AWF_TimeSlice*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
} // end of namespace ROOT

namespace ROOT {
   static void *new_DWF_TimeSlice(void *p = 0);
   static void *newArray_DWF_TimeSlice(Long_t size, void *p);
   static void delete_DWF_TimeSlice(void *p);
   static void deleteArray_DWF_TimeSlice(void *p);
   static void destruct_DWF_TimeSlice(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::DWF_TimeSlice*)
   {
      ::DWF_TimeSlice *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::DWF_TimeSlice >(0);
      static ::ROOT::TGenericClassInfo 
         instance("DWF_TimeSlice", ::DWF_TimeSlice::Class_Version(), "", 1251,
                  typeid(::DWF_TimeSlice), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &::DWF_TimeSlice::Dictionary, isa_proxy, 4,
                  sizeof(::DWF_TimeSlice) );
      instance.SetNew(&new_DWF_TimeSlice);
      instance.SetNewArray(&newArray_DWF_TimeSlice);
      instance.SetDelete(&delete_DWF_TimeSlice);
      instance.SetDeleteArray(&deleteArray_DWF_TimeSlice);
      instance.SetDestructor(&destruct_DWF_TimeSlice);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::DWF_TimeSlice*)
   {
      return GenerateInitInstanceLocal((::DWF_TimeSlice*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::DWF_TimeSlice*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
} // end of namespace ROOT

namespace ROOT {
   static void *new_Summary_TimeSlice(void *p = 0);
   static void *newArray_Summary_TimeSlice(Long_t size, void *p);
   static void delete_Summary_TimeSlice(void *p);
   static void deleteArray_Summary_TimeSlice(void *p);
   static void destruct_Summary_TimeSlice(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::Summary_TimeSlice*)
   {
      ::Summary_TimeSlice *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::Summary_TimeSlice >(0);
      static ::ROOT::TGenericClassInfo 
         instance("Summary_TimeSlice", ::Summary_TimeSlice::Class_Version(), "", 1268,
                  typeid(::Summary_TimeSlice), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &::Summary_TimeSlice::Dictionary, isa_proxy, 4,
                  sizeof(::Summary_TimeSlice) );
      instance.SetNew(&new_Summary_TimeSlice);
      instance.SetNewArray(&newArray_Summary_TimeSlice);
      instance.SetDelete(&delete_Summary_TimeSlice);
      instance.SetDeleteArray(&deleteArray_Summary_TimeSlice);
      instance.SetDestructor(&destruct_Summary_TimeSlice);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::Summary_TimeSlice*)
   {
      return GenerateInitInstanceLocal((::Summary_TimeSlice*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::Summary_TimeSlice*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
} // end of namespace ROOT

namespace ROOT {
   static void *new_ExtendedSummary_TimeSlice(void *p = 0);
   static void *newArray_ExtendedSummary_TimeSlice(Long_t size, void *p);
   static void delete_ExtendedSummary_TimeSlice(void *p);
   static void deleteArray_ExtendedSummary_TimeSlice(void *p);
   static void destruct_ExtendedSummary_TimeSlice(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::ExtendedSummary_TimeSlice*)
   {
      ::ExtendedSummary_TimeSlice *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::ExtendedSummary_TimeSlice >(0);
      static ::ROOT::TGenericClassInfo 
         instance("ExtendedSummary_TimeSlice", ::ExtendedSummary_TimeSlice::Class_Version(), "", 1323,
                  typeid(::ExtendedSummary_TimeSlice), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &::ExtendedSummary_TimeSlice::Dictionary, isa_proxy, 4,
                  sizeof(::ExtendedSummary_TimeSlice) );
      instance.SetNew(&new_ExtendedSummary_TimeSlice);
      instance.SetNewArray(&newArray_ExtendedSummary_TimeSlice);
      instance.SetDelete(&delete_ExtendedSummary_TimeSlice);
      instance.SetDeleteArray(&deleteArray_ExtendedSummary_TimeSlice);
      instance.SetDestructor(&destruct_ExtendedSummary_TimeSlice);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::ExtendedSummary_TimeSlice*)
   {
      return GenerateInitInstanceLocal((::ExtendedSummary_TimeSlice*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::ExtendedSummary_TimeSlice*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
} // end of namespace ROOT

namespace ROOT {
   static TClass *ARS_HitlESPE_ItemgR_Dictionary();
   static void ARS_HitlESPE_ItemgR_TClassManip(TClass*);
   static void *new_ARS_HitlESPE_ItemgR(void *p = 0);
   static void *newArray_ARS_HitlESPE_ItemgR(Long_t size, void *p);
   static void delete_ARS_HitlESPE_ItemgR(void *p);
   static void deleteArray_ARS_HitlESPE_ItemgR(void *p);
   static void destruct_ARS_HitlESPE_ItemgR(void *p);
   static void streamer_ARS_HitlESPE_ItemgR(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::ARS_Hit<SPE_Item>*)
   {
      ::ARS_Hit<SPE_Item> *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::ARS_Hit<SPE_Item> >(0);
      static ::ROOT::TGenericClassInfo 
         instance("ARS_Hit<SPE_Item>", ::ARS_Hit<SPE_Item>::Class_Version(), "", 1434,
                  typeid(::ARS_Hit<SPE_Item>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &ARS_HitlESPE_ItemgR_Dictionary, isa_proxy, 17,
                  sizeof(::ARS_Hit<SPE_Item>) );
      instance.SetNew(&new_ARS_HitlESPE_ItemgR);
      instance.SetNewArray(&newArray_ARS_HitlESPE_ItemgR);
      instance.SetDelete(&delete_ARS_HitlESPE_ItemgR);
      instance.SetDeleteArray(&deleteArray_ARS_HitlESPE_ItemgR);
      instance.SetDestructor(&destruct_ARS_HitlESPE_ItemgR);
      instance.SetStreamerFunc(&streamer_ARS_HitlESPE_ItemgR);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::ARS_Hit<SPE_Item>*)
   {
      return GenerateInitInstanceLocal((::ARS_Hit<SPE_Item>*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::ARS_Hit<SPE_Item>*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *ARS_HitlESPE_ItemgR_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::ARS_Hit<SPE_Item>*)0x0)->GetClass();
      ARS_HitlESPE_ItemgR_TClassManip(theClass);
   return theClass;
   }

   static void ARS_HitlESPE_ItemgR_TClassManip(TClass* ){
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *ARS_HitlEAWF_ItemgR_Dictionary();
   static void ARS_HitlEAWF_ItemgR_TClassManip(TClass*);
   static void *new_ARS_HitlEAWF_ItemgR(void *p = 0);
   static void *newArray_ARS_HitlEAWF_ItemgR(Long_t size, void *p);
   static void delete_ARS_HitlEAWF_ItemgR(void *p);
   static void deleteArray_ARS_HitlEAWF_ItemgR(void *p);
   static void destruct_ARS_HitlEAWF_ItemgR(void *p);
   static void streamer_ARS_HitlEAWF_ItemgR(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::ARS_Hit<AWF_Item>*)
   {
      ::ARS_Hit<AWF_Item> *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::ARS_Hit<AWF_Item> >(0);
      static ::ROOT::TGenericClassInfo 
         instance("ARS_Hit<AWF_Item>", ::ARS_Hit<AWF_Item>::Class_Version(), "", 1434,
                  typeid(::ARS_Hit<AWF_Item>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &ARS_HitlEAWF_ItemgR_Dictionary, isa_proxy, 17,
                  sizeof(::ARS_Hit<AWF_Item>) );
      instance.SetNew(&new_ARS_HitlEAWF_ItemgR);
      instance.SetNewArray(&newArray_ARS_HitlEAWF_ItemgR);
      instance.SetDelete(&delete_ARS_HitlEAWF_ItemgR);
      instance.SetDeleteArray(&deleteArray_ARS_HitlEAWF_ItemgR);
      instance.SetDestructor(&destruct_ARS_HitlEAWF_ItemgR);
      instance.SetStreamerFunc(&streamer_ARS_HitlEAWF_ItemgR);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::ARS_Hit<AWF_Item>*)
   {
      return GenerateInitInstanceLocal((::ARS_Hit<AWF_Item>*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::ARS_Hit<AWF_Item>*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *ARS_HitlEAWF_ItemgR_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::ARS_Hit<AWF_Item>*)0x0)->GetClass();
      ARS_HitlEAWF_ItemgR_TClassManip(theClass);
   return theClass;
   }

   static void ARS_HitlEAWF_ItemgR_TClassManip(TClass* ){
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *ARS_HitlEDWF_ItemgR_Dictionary();
   static void ARS_HitlEDWF_ItemgR_TClassManip(TClass*);
   static void *new_ARS_HitlEDWF_ItemgR(void *p = 0);
   static void *newArray_ARS_HitlEDWF_ItemgR(Long_t size, void *p);
   static void delete_ARS_HitlEDWF_ItemgR(void *p);
   static void deleteArray_ARS_HitlEDWF_ItemgR(void *p);
   static void destruct_ARS_HitlEDWF_ItemgR(void *p);
   static void streamer_ARS_HitlEDWF_ItemgR(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::ARS_Hit<DWF_Item>*)
   {
      ::ARS_Hit<DWF_Item> *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::ARS_Hit<DWF_Item> >(0);
      static ::ROOT::TGenericClassInfo 
         instance("ARS_Hit<DWF_Item>", ::ARS_Hit<DWF_Item>::Class_Version(), "", 1434,
                  typeid(::ARS_Hit<DWF_Item>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &ARS_HitlEDWF_ItemgR_Dictionary, isa_proxy, 17,
                  sizeof(::ARS_Hit<DWF_Item>) );
      instance.SetNew(&new_ARS_HitlEDWF_ItemgR);
      instance.SetNewArray(&newArray_ARS_HitlEDWF_ItemgR);
      instance.SetDelete(&delete_ARS_HitlEDWF_ItemgR);
      instance.SetDeleteArray(&deleteArray_ARS_HitlEDWF_ItemgR);
      instance.SetDestructor(&destruct_ARS_HitlEDWF_ItemgR);
      instance.SetStreamerFunc(&streamer_ARS_HitlEDWF_ItemgR);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::ARS_Hit<DWF_Item>*)
   {
      return GenerateInitInstanceLocal((::ARS_Hit<DWF_Item>*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::ARS_Hit<DWF_Item>*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *ARS_HitlEDWF_ItemgR_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::ARS_Hit<DWF_Item>*)0x0)->GetClass();
      ARS_HitlEDWF_ItemgR_TClassManip(theClass);
   return theClass;
   }

   static void ARS_HitlEDWF_ItemgR_TClassManip(TClass* ){
   }

} // end of namespace ROOT

namespace ROOT {
   static void *new_SPE_Hit(void *p = 0);
   static void *newArray_SPE_Hit(Long_t size, void *p);
   static void delete_SPE_Hit(void *p);
   static void deleteArray_SPE_Hit(void *p);
   static void destruct_SPE_Hit(void *p);
   static void streamer_SPE_Hit(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::SPE_Hit*)
   {
      ::SPE_Hit *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::SPE_Hit >(0);
      static ::ROOT::TGenericClassInfo 
         instance("SPE_Hit", ::SPE_Hit::Class_Version(), "", 1479,
                  typeid(::SPE_Hit), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &::SPE_Hit::Dictionary, isa_proxy, 17,
                  sizeof(::SPE_Hit) );
      instance.SetNew(&new_SPE_Hit);
      instance.SetNewArray(&newArray_SPE_Hit);
      instance.SetDelete(&delete_SPE_Hit);
      instance.SetDeleteArray(&deleteArray_SPE_Hit);
      instance.SetDestructor(&destruct_SPE_Hit);
      instance.SetStreamerFunc(&streamer_SPE_Hit);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::SPE_Hit*)
   {
      return GenerateInitInstanceLocal((::SPE_Hit*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::SPE_Hit*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
} // end of namespace ROOT

namespace ROOT {
   static void *new_AWF_Hit(void *p = 0);
   static void *newArray_AWF_Hit(Long_t size, void *p);
   static void delete_AWF_Hit(void *p);
   static void deleteArray_AWF_Hit(void *p);
   static void destruct_AWF_Hit(void *p);
   static void streamer_AWF_Hit(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::AWF_Hit*)
   {
      ::AWF_Hit *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::AWF_Hit >(0);
      static ::ROOT::TGenericClassInfo 
         instance("AWF_Hit", ::AWF_Hit::Class_Version(), "", 1495,
                  typeid(::AWF_Hit), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &::AWF_Hit::Dictionary, isa_proxy, 17,
                  sizeof(::AWF_Hit) );
      instance.SetNew(&new_AWF_Hit);
      instance.SetNewArray(&newArray_AWF_Hit);
      instance.SetDelete(&delete_AWF_Hit);
      instance.SetDeleteArray(&deleteArray_AWF_Hit);
      instance.SetDestructor(&destruct_AWF_Hit);
      instance.SetStreamerFunc(&streamer_AWF_Hit);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::AWF_Hit*)
   {
      return GenerateInitInstanceLocal((::AWF_Hit*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::AWF_Hit*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
} // end of namespace ROOT

namespace ROOT {
   static void *new_DWF_Hit(void *p = 0);
   static void *newArray_DWF_Hit(Long_t size, void *p);
   static void delete_DWF_Hit(void *p);
   static void deleteArray_DWF_Hit(void *p);
   static void destruct_DWF_Hit(void *p);
   static void streamer_DWF_Hit(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::DWF_Hit*)
   {
      ::DWF_Hit *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::DWF_Hit >(0);
      static ::ROOT::TGenericClassInfo 
         instance("DWF_Hit", ::DWF_Hit::Class_Version(), "", 1511,
                  typeid(::DWF_Hit), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &::DWF_Hit::Dictionary, isa_proxy, 17,
                  sizeof(::DWF_Hit) );
      instance.SetNew(&new_DWF_Hit);
      instance.SetNewArray(&newArray_DWF_Hit);
      instance.SetDelete(&delete_DWF_Hit);
      instance.SetDeleteArray(&deleteArray_DWF_Hit);
      instance.SetDestructor(&destruct_DWF_Hit);
      instance.SetStreamerFunc(&streamer_DWF_Hit);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::DWF_Hit*)
   {
      return GenerateInitInstanceLocal((::DWF_Hit*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::DWF_Hit*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
} // end of namespace ROOT

namespace ROOT {
   static void *new_TriggeredSPE_Hit(void *p = 0);
   static void *newArray_TriggeredSPE_Hit(Long_t size, void *p);
   static void delete_TriggeredSPE_Hit(void *p);
   static void deleteArray_TriggeredSPE_Hit(void *p);
   static void destruct_TriggeredSPE_Hit(void *p);
   static void streamer_TriggeredSPE_Hit(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TriggeredSPE_Hit*)
   {
      ::TriggeredSPE_Hit *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TriggeredSPE_Hit >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TriggeredSPE_Hit", ::TriggeredSPE_Hit::Class_Version(), "", 1527,
                  typeid(::TriggeredSPE_Hit), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &::TriggeredSPE_Hit::Dictionary, isa_proxy, 17,
                  sizeof(::TriggeredSPE_Hit) );
      instance.SetNew(&new_TriggeredSPE_Hit);
      instance.SetNewArray(&newArray_TriggeredSPE_Hit);
      instance.SetDelete(&delete_TriggeredSPE_Hit);
      instance.SetDeleteArray(&deleteArray_TriggeredSPE_Hit);
      instance.SetDestructor(&destruct_TriggeredSPE_Hit);
      instance.SetStreamerFunc(&streamer_TriggeredSPE_Hit);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TriggeredSPE_Hit*)
   {
      return GenerateInitInstanceLocal((::TriggeredSPE_Hit*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::TriggeredSPE_Hit*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
} // end of namespace ROOT

namespace ROOT {
   static void *new_PhysicsEvent(void *p = 0);
   static void *newArray_PhysicsEvent(Long_t size, void *p);
   static void delete_PhysicsEvent(void *p);
   static void deleteArray_PhysicsEvent(void *p);
   static void destruct_PhysicsEvent(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::PhysicsEvent*)
   {
      ::PhysicsEvent *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::PhysicsEvent >(0);
      static ::ROOT::TGenericClassInfo 
         instance("PhysicsEvent", ::PhysicsEvent::Class_Version(), "", 1543,
                  typeid(::PhysicsEvent), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &::PhysicsEvent::Dictionary, isa_proxy, 4,
                  sizeof(::PhysicsEvent) );
      instance.SetNew(&new_PhysicsEvent);
      instance.SetNewArray(&newArray_PhysicsEvent);
      instance.SetDelete(&delete_PhysicsEvent);
      instance.SetDeleteArray(&deleteArray_PhysicsEvent);
      instance.SetDestructor(&destruct_PhysicsEvent);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::PhysicsEvent*)
   {
      return GenerateInitInstanceLocal((::PhysicsEvent*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::PhysicsEvent*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
} // end of namespace ROOT

//______________________________________________________________________________
atomic_TClass_ptr ARS_Item::fgIsA(0);  // static to hold class pointer

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

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

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

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

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

//______________________________________________________________________________
atomic_TClass_ptr Status_Item::fgIsA(0);  // static to hold class pointer

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

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

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

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

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

//______________________________________________________________________________
atomic_TClass_ptr RTS_Item::fgIsA(0);  // static to hold class pointer

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

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

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

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

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

//______________________________________________________________________________
atomic_TClass_ptr CRM_Item::fgIsA(0);  // static to hold class pointer

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

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

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

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

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

//______________________________________________________________________________
atomic_TClass_ptr SPE_Item::fgIsA(0);  // static to hold class pointer

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

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

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

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

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

//______________________________________________________________________________
atomic_TClass_ptr AWF_Sample::fgIsA(0);  // static to hold class pointer

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

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

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

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

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

//______________________________________________________________________________
atomic_TClass_ptr DWF_Sample::fgIsA(0);  // static to hold class pointer

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

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

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

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

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

//______________________________________________________________________________
atomic_TClass_ptr WF_Header::fgIsA(0);  // static to hold class pointer

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

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

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

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

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

//______________________________________________________________________________
template <> atomic_TClass_ptr WF_Item<AWF_Sample>::fgIsA(0);  // static to hold class pointer

//______________________________________________________________________________
template <> const char *WF_Item<AWF_Sample>::Class_Name()
{
   return "WF_Item<AWF_Sample>";
}

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

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

//______________________________________________________________________________
template <> TClass *WF_Item<AWF_Sample>::Dictionary()
{
   fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::WF_Item<AWF_Sample>*)0x0)->GetClass();
   return fgIsA;
}

//______________________________________________________________________________
template <> TClass *WF_Item<AWF_Sample>::Class()
{
   if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::WF_Item<AWF_Sample>*)0x0)->GetClass(); }
   return fgIsA;
}

//______________________________________________________________________________
template <> atomic_TClass_ptr WF_Item<DWF_Sample>::fgIsA(0);  // static to hold class pointer

//______________________________________________________________________________
template <> const char *WF_Item<DWF_Sample>::Class_Name()
{
   return "WF_Item<DWF_Sample>";
}

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

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

//______________________________________________________________________________
template <> TClass *WF_Item<DWF_Sample>::Dictionary()
{
   fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::WF_Item<DWF_Sample>*)0x0)->GetClass();
   return fgIsA;
}

//______________________________________________________________________________
template <> TClass *WF_Item<DWF_Sample>::Class()
{
   if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::WF_Item<DWF_Sample>*)0x0)->GetClass(); }
   return fgIsA;
}

//______________________________________________________________________________
atomic_TClass_ptr AWF_Item::fgIsA(0);  // static to hold class pointer

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

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

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

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

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

//______________________________________________________________________________
atomic_TClass_ptr DWF_Item::fgIsA(0);  // static to hold class pointer

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

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

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

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

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

//______________________________________________________________________________
atomic_TClass_ptr DaqFramePreamble::fgIsA(0);  // static to hold class pointer

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

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

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

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

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

//______________________________________________________________________________
atomic_TClass_ptr EventPreamble::fgIsA(0);  // static to hold class pointer

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

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

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

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

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

//______________________________________________________________________________
atomic_TClass_ptr Summary_Frame::fgIsA(0);  // static to hold class pointer

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

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

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

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

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

//______________________________________________________________________________
atomic_TClass_ptr ExtendedSummary_Frame::fgIsA(0);  // static to hold class pointer

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

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

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

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

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

//______________________________________________________________________________
template <> atomic_TClass_ptr Frame<Status_Item>::fgIsA(0);  // static to hold class pointer

//______________________________________________________________________________
template <> const char *Frame<Status_Item>::Class_Name()
{
   return "Frame<Status_Item>";
}

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

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

//______________________________________________________________________________
template <> TClass *Frame<Status_Item>::Dictionary()
{
   fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::Frame<Status_Item>*)0x0)->GetClass();
   return fgIsA;
}

//______________________________________________________________________________
template <> TClass *Frame<Status_Item>::Class()
{
   if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::Frame<Status_Item>*)0x0)->GetClass(); }
   return fgIsA;
}

//______________________________________________________________________________
template <> atomic_TClass_ptr Frame<RTS_Item>::fgIsA(0);  // static to hold class pointer

//______________________________________________________________________________
template <> const char *Frame<RTS_Item>::Class_Name()
{
   return "Frame<RTS_Item>";
}

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

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

//______________________________________________________________________________
template <> TClass *Frame<RTS_Item>::Dictionary()
{
   fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::Frame<RTS_Item>*)0x0)->GetClass();
   return fgIsA;
}

//______________________________________________________________________________
template <> TClass *Frame<RTS_Item>::Class()
{
   if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::Frame<RTS_Item>*)0x0)->GetClass(); }
   return fgIsA;
}

//______________________________________________________________________________
template <> atomic_TClass_ptr Frame<CRM_Item>::fgIsA(0);  // static to hold class pointer

//______________________________________________________________________________
template <> const char *Frame<CRM_Item>::Class_Name()
{
   return "Frame<CRM_Item>";
}

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

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

//______________________________________________________________________________
template <> TClass *Frame<CRM_Item>::Dictionary()
{
   fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::Frame<CRM_Item>*)0x0)->GetClass();
   return fgIsA;
}

//______________________________________________________________________________
template <> TClass *Frame<CRM_Item>::Class()
{
   if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::Frame<CRM_Item>*)0x0)->GetClass(); }
   return fgIsA;
}

//______________________________________________________________________________
template <> atomic_TClass_ptr Frame<SPE_Item>::fgIsA(0);  // static to hold class pointer

//______________________________________________________________________________
template <> const char *Frame<SPE_Item>::Class_Name()
{
   return "Frame<SPE_Item>";
}

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

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

//______________________________________________________________________________
template <> TClass *Frame<SPE_Item>::Dictionary()
{
   fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::Frame<SPE_Item>*)0x0)->GetClass();
   return fgIsA;
}

//______________________________________________________________________________
template <> TClass *Frame<SPE_Item>::Class()
{
   if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::Frame<SPE_Item>*)0x0)->GetClass(); }
   return fgIsA;
}

//______________________________________________________________________________
template <> atomic_TClass_ptr Frame<AWF_Item>::fgIsA(0);  // static to hold class pointer

//______________________________________________________________________________
template <> const char *Frame<AWF_Item>::Class_Name()
{
   return "Frame<AWF_Item>";
}

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

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

//______________________________________________________________________________
template <> TClass *Frame<AWF_Item>::Dictionary()
{
   fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::Frame<AWF_Item>*)0x0)->GetClass();
   return fgIsA;
}

//______________________________________________________________________________
template <> TClass *Frame<AWF_Item>::Class()
{
   if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::Frame<AWF_Item>*)0x0)->GetClass(); }
   return fgIsA;
}

//______________________________________________________________________________
template <> atomic_TClass_ptr Frame<DWF_Item>::fgIsA(0);  // static to hold class pointer

//______________________________________________________________________________
template <> const char *Frame<DWF_Item>::Class_Name()
{
   return "Frame<DWF_Item>";
}

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

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

//______________________________________________________________________________
template <> TClass *Frame<DWF_Item>::Dictionary()
{
   fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::Frame<DWF_Item>*)0x0)->GetClass();
   return fgIsA;
}

//______________________________________________________________________________
template <> TClass *Frame<DWF_Item>::Class()
{
   if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::Frame<DWF_Item>*)0x0)->GetClass(); }
   return fgIsA;
}

//______________________________________________________________________________
atomic_TClass_ptr Status_Frame::fgIsA(0);  // static to hold class pointer

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

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

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

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

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

//______________________________________________________________________________
atomic_TClass_ptr RTS_Frame::fgIsA(0);  // static to hold class pointer

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

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

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

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

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

//______________________________________________________________________________
atomic_TClass_ptr CRM_Frame::fgIsA(0);  // static to hold class pointer

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

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

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

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

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

//______________________________________________________________________________
atomic_TClass_ptr SPE_Frame::fgIsA(0);  // static to hold class pointer

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

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

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

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

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

//______________________________________________________________________________
atomic_TClass_ptr AWF_Frame::fgIsA(0);  // static to hold class pointer

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

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

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

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

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

//______________________________________________________________________________
atomic_TClass_ptr DWF_Frame::fgIsA(0);  // static to hold class pointer

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

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

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

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

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

//______________________________________________________________________________
template <> atomic_TClass_ptr TimeSlice<Status_Frame>::fgIsA(0);  // static to hold class pointer

//______________________________________________________________________________
template <> const char *TimeSlice<Status_Frame>::Class_Name()
{
   return "TimeSlice<Status_Frame>";
}

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

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

//______________________________________________________________________________
template <> TClass *TimeSlice<Status_Frame>::Dictionary()
{
   fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TimeSlice<Status_Frame>*)0x0)->GetClass();
   return fgIsA;
}

//______________________________________________________________________________
template <> TClass *TimeSlice<Status_Frame>::Class()
{
   if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TimeSlice<Status_Frame>*)0x0)->GetClass(); }
   return fgIsA;
}

//______________________________________________________________________________
template <> atomic_TClass_ptr TimeSlice<RTS_Frame>::fgIsA(0);  // static to hold class pointer

//______________________________________________________________________________
template <> const char *TimeSlice<RTS_Frame>::Class_Name()
{
   return "TimeSlice<RTS_Frame>";
}

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

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

//______________________________________________________________________________
template <> TClass *TimeSlice<RTS_Frame>::Dictionary()
{
   fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TimeSlice<RTS_Frame>*)0x0)->GetClass();
   return fgIsA;
}

//______________________________________________________________________________
template <> TClass *TimeSlice<RTS_Frame>::Class()
{
   if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TimeSlice<RTS_Frame>*)0x0)->GetClass(); }
   return fgIsA;
}

//______________________________________________________________________________
template <> atomic_TClass_ptr TimeSlice<CRM_Frame>::fgIsA(0);  // static to hold class pointer

//______________________________________________________________________________
template <> const char *TimeSlice<CRM_Frame>::Class_Name()
{
   return "TimeSlice<CRM_Frame>";
}

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

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

//______________________________________________________________________________
template <> TClass *TimeSlice<CRM_Frame>::Dictionary()
{
   fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TimeSlice<CRM_Frame>*)0x0)->GetClass();
   return fgIsA;
}

//______________________________________________________________________________
template <> TClass *TimeSlice<CRM_Frame>::Class()
{
   if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TimeSlice<CRM_Frame>*)0x0)->GetClass(); }
   return fgIsA;
}

//______________________________________________________________________________
template <> atomic_TClass_ptr TimeSlice<SPE_Frame>::fgIsA(0);  // static to hold class pointer

//______________________________________________________________________________
template <> const char *TimeSlice<SPE_Frame>::Class_Name()
{
   return "TimeSlice<SPE_Frame>";
}

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

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

//______________________________________________________________________________
template <> TClass *TimeSlice<SPE_Frame>::Dictionary()
{
   fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TimeSlice<SPE_Frame>*)0x0)->GetClass();
   return fgIsA;
}

//______________________________________________________________________________
template <> TClass *TimeSlice<SPE_Frame>::Class()
{
   if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TimeSlice<SPE_Frame>*)0x0)->GetClass(); }
   return fgIsA;
}

//______________________________________________________________________________
template <> atomic_TClass_ptr TimeSlice<AWF_Frame>::fgIsA(0);  // static to hold class pointer

//______________________________________________________________________________
template <> const char *TimeSlice<AWF_Frame>::Class_Name()
{
   return "TimeSlice<AWF_Frame>";
}

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

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

//______________________________________________________________________________
template <> TClass *TimeSlice<AWF_Frame>::Dictionary()
{
   fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TimeSlice<AWF_Frame>*)0x0)->GetClass();
   return fgIsA;
}

//______________________________________________________________________________
template <> TClass *TimeSlice<AWF_Frame>::Class()
{
   if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TimeSlice<AWF_Frame>*)0x0)->GetClass(); }
   return fgIsA;
}

//______________________________________________________________________________
template <> atomic_TClass_ptr TimeSlice<DWF_Frame>::fgIsA(0);  // static to hold class pointer

//______________________________________________________________________________
template <> const char *TimeSlice<DWF_Frame>::Class_Name()
{
   return "TimeSlice<DWF_Frame>";
}

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

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

//______________________________________________________________________________
template <> TClass *TimeSlice<DWF_Frame>::Dictionary()
{
   fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TimeSlice<DWF_Frame>*)0x0)->GetClass();
   return fgIsA;
}

//______________________________________________________________________________
template <> TClass *TimeSlice<DWF_Frame>::Class()
{
   if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TimeSlice<DWF_Frame>*)0x0)->GetClass(); }
   return fgIsA;
}

//______________________________________________________________________________
template <> atomic_TClass_ptr TimeSlice<Summary_Frame>::fgIsA(0);  // static to hold class pointer

//______________________________________________________________________________
template <> const char *TimeSlice<Summary_Frame>::Class_Name()
{
   return "TimeSlice<Summary_Frame>";
}

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

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

//______________________________________________________________________________
template <> TClass *TimeSlice<Summary_Frame>::Dictionary()
{
   fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TimeSlice<Summary_Frame>*)0x0)->GetClass();
   return fgIsA;
}

//______________________________________________________________________________
template <> TClass *TimeSlice<Summary_Frame>::Class()
{
   if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TimeSlice<Summary_Frame>*)0x0)->GetClass(); }
   return fgIsA;
}

//______________________________________________________________________________
template <> atomic_TClass_ptr TimeSlice<ExtendedSummary_Frame>::fgIsA(0);  // static to hold class pointer

//______________________________________________________________________________
template <> const char *TimeSlice<ExtendedSummary_Frame>::Class_Name()
{
   return "TimeSlice<ExtendedSummary_Frame>";
}

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

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

//______________________________________________________________________________
template <> TClass *TimeSlice<ExtendedSummary_Frame>::Dictionary()
{
   fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TimeSlice<ExtendedSummary_Frame>*)0x0)->GetClass();
   return fgIsA;
}

//______________________________________________________________________________
template <> TClass *TimeSlice<ExtendedSummary_Frame>::Class()
{
   if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TimeSlice<ExtendedSummary_Frame>*)0x0)->GetClass(); }
   return fgIsA;
}

//______________________________________________________________________________
atomic_TClass_ptr Status_TimeSlice::fgIsA(0);  // static to hold class pointer

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

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

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

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

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

//______________________________________________________________________________
atomic_TClass_ptr RTS_TimeSlice::fgIsA(0);  // static to hold class pointer

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

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

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

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

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

//______________________________________________________________________________
atomic_TClass_ptr CRM_TimeSlice::fgIsA(0);  // static to hold class pointer

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

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

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

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

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

//______________________________________________________________________________
atomic_TClass_ptr SPE_TimeSlice::fgIsA(0);  // static to hold class pointer

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

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

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

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

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

//______________________________________________________________________________
atomic_TClass_ptr AWF_TimeSlice::fgIsA(0);  // static to hold class pointer

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

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

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

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

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

//______________________________________________________________________________
atomic_TClass_ptr DWF_TimeSlice::fgIsA(0);  // static to hold class pointer

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

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

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

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

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

//______________________________________________________________________________
atomic_TClass_ptr Summary_TimeSlice::fgIsA(0);  // static to hold class pointer

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

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

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

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

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

//______________________________________________________________________________
atomic_TClass_ptr ExtendedSummary_TimeSlice::fgIsA(0);  // static to hold class pointer

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

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

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

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

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

//______________________________________________________________________________
template <> atomic_TClass_ptr ARS_Hit<SPE_Item>::fgIsA(0);  // static to hold class pointer

//______________________________________________________________________________
template <> const char *ARS_Hit<SPE_Item>::Class_Name()
{
   return "ARS_Hit<SPE_Item>";
}

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

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

//______________________________________________________________________________
template <> TClass *ARS_Hit<SPE_Item>::Dictionary()
{
   fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::ARS_Hit<SPE_Item>*)0x0)->GetClass();
   return fgIsA;
}

//______________________________________________________________________________
template <> TClass *ARS_Hit<SPE_Item>::Class()
{
   if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::ARS_Hit<SPE_Item>*)0x0)->GetClass(); }
   return fgIsA;
}

//______________________________________________________________________________
template <> atomic_TClass_ptr ARS_Hit<AWF_Item>::fgIsA(0);  // static to hold class pointer

//______________________________________________________________________________
template <> const char *ARS_Hit<AWF_Item>::Class_Name()
{
   return "ARS_Hit<AWF_Item>";
}

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

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

//______________________________________________________________________________
template <> TClass *ARS_Hit<AWF_Item>::Dictionary()
{
   fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::ARS_Hit<AWF_Item>*)0x0)->GetClass();
   return fgIsA;
}

//______________________________________________________________________________
template <> TClass *ARS_Hit<AWF_Item>::Class()
{
   if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::ARS_Hit<AWF_Item>*)0x0)->GetClass(); }
   return fgIsA;
}

//______________________________________________________________________________
template <> atomic_TClass_ptr ARS_Hit<DWF_Item>::fgIsA(0);  // static to hold class pointer

//______________________________________________________________________________
template <> const char *ARS_Hit<DWF_Item>::Class_Name()
{
   return "ARS_Hit<DWF_Item>";
}

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

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

//______________________________________________________________________________
template <> TClass *ARS_Hit<DWF_Item>::Dictionary()
{
   fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::ARS_Hit<DWF_Item>*)0x0)->GetClass();
   return fgIsA;
}

//______________________________________________________________________________
template <> TClass *ARS_Hit<DWF_Item>::Class()
{
   if (!fgIsA.load()) { R__LOCKGUARD(gInterpreterMutex); fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::ARS_Hit<DWF_Item>*)0x0)->GetClass(); }
   return fgIsA;
}

//______________________________________________________________________________
atomic_TClass_ptr SPE_Hit::fgIsA(0);  // static to hold class pointer

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

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

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

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

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

//______________________________________________________________________________
atomic_TClass_ptr AWF_Hit::fgIsA(0);  // static to hold class pointer

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

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

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

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

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

//______________________________________________________________________________
atomic_TClass_ptr DWF_Hit::fgIsA(0);  // static to hold class pointer

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

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

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

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

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

//______________________________________________________________________________
atomic_TClass_ptr TriggeredSPE_Hit::fgIsA(0);  // static to hold class pointer

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

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

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

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

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

//______________________________________________________________________________
atomic_TClass_ptr PhysicsEvent::fgIsA(0);  // static to hold class pointer

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

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

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

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

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_ARS_Item(void *p) {
      return  p ? new(p) ::ARS_Item : new ::ARS_Item;
   }
   static void *newArray_ARS_Item(Long_t nElements, void *p) {
      return p ? new(p) ::ARS_Item[nElements] : new ::ARS_Item[nElements];
   }
   // Wrapper around operator delete
   static void delete_ARS_Item(void *p) {
      delete ((::ARS_Item*)p);
   }
   static void deleteArray_ARS_Item(void *p) {
      delete [] ((::ARS_Item*)p);
   }
   static void destruct_ARS_Item(void *p) {
      typedef ::ARS_Item current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_ARS_Item(TBuffer &buf, void *obj) {
      ((::ARS_Item*)obj)->::ARS_Item::Streamer(buf);
   }
} // end of namespace ROOT for class ::ARS_Item

namespace ROOT {
   // Wrappers around operator new
   static void *new_Status_Item(void *p) {
      return  p ? new(p) ::Status_Item : new ::Status_Item;
   }
   static void *newArray_Status_Item(Long_t nElements, void *p) {
      return p ? new(p) ::Status_Item[nElements] : new ::Status_Item[nElements];
   }
   // Wrapper around operator delete
   static void delete_Status_Item(void *p) {
      delete ((::Status_Item*)p);
   }
   static void deleteArray_Status_Item(void *p) {
      delete [] ((::Status_Item*)p);
   }
   static void destruct_Status_Item(void *p) {
      typedef ::Status_Item current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_Status_Item(TBuffer &buf, void *obj) {
      ((::Status_Item*)obj)->::Status_Item::Streamer(buf);
   }
} // end of namespace ROOT for class ::Status_Item

namespace ROOT {
   // Wrappers around operator new
   static void *new_RTS_Item(void *p) {
      return  p ? new(p) ::RTS_Item : new ::RTS_Item;
   }
   static void *newArray_RTS_Item(Long_t nElements, void *p) {
      return p ? new(p) ::RTS_Item[nElements] : new ::RTS_Item[nElements];
   }
   // Wrapper around operator delete
   static void delete_RTS_Item(void *p) {
      delete ((::RTS_Item*)p);
   }
   static void deleteArray_RTS_Item(void *p) {
      delete [] ((::RTS_Item*)p);
   }
   static void destruct_RTS_Item(void *p) {
      typedef ::RTS_Item current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_RTS_Item(TBuffer &buf, void *obj) {
      ((::RTS_Item*)obj)->::RTS_Item::Streamer(buf);
   }
} // end of namespace ROOT for class ::RTS_Item

namespace ROOT {
   // Wrappers around operator new
   static void *new_CRM_Item(void *p) {
      return  p ? new(p) ::CRM_Item : new ::CRM_Item;
   }
   static void *newArray_CRM_Item(Long_t nElements, void *p) {
      return p ? new(p) ::CRM_Item[nElements] : new ::CRM_Item[nElements];
   }
   // Wrapper around operator delete
   static void delete_CRM_Item(void *p) {
      delete ((::CRM_Item*)p);
   }
   static void deleteArray_CRM_Item(void *p) {
      delete [] ((::CRM_Item*)p);
   }
   static void destruct_CRM_Item(void *p) {
      typedef ::CRM_Item current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_CRM_Item(TBuffer &buf, void *obj) {
      ((::CRM_Item*)obj)->::CRM_Item::Streamer(buf);
   }
} // end of namespace ROOT for class ::CRM_Item

namespace ROOT {
   // Wrappers around operator new
   static void *new_SPE_Item(void *p) {
      return  p ? new(p) ::SPE_Item : new ::SPE_Item;
   }
   static void *newArray_SPE_Item(Long_t nElements, void *p) {
      return p ? new(p) ::SPE_Item[nElements] : new ::SPE_Item[nElements];
   }
   // Wrapper around operator delete
   static void delete_SPE_Item(void *p) {
      delete ((::SPE_Item*)p);
   }
   static void deleteArray_SPE_Item(void *p) {
      delete [] ((::SPE_Item*)p);
   }
   static void destruct_SPE_Item(void *p) {
      typedef ::SPE_Item current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_SPE_Item(TBuffer &buf, void *obj) {
      ((::SPE_Item*)obj)->::SPE_Item::Streamer(buf);
   }
} // end of namespace ROOT for class ::SPE_Item

namespace ROOT {
   // Wrappers around operator new
   static void *new_AWF_Sample(void *p) {
      return  p ? new(p) ::AWF_Sample : new ::AWF_Sample;
   }
   static void *newArray_AWF_Sample(Long_t nElements, void *p) {
      return p ? new(p) ::AWF_Sample[nElements] : new ::AWF_Sample[nElements];
   }
   // Wrapper around operator delete
   static void delete_AWF_Sample(void *p) {
      delete ((::AWF_Sample*)p);
   }
   static void deleteArray_AWF_Sample(void *p) {
      delete [] ((::AWF_Sample*)p);
   }
   static void destruct_AWF_Sample(void *p) {
      typedef ::AWF_Sample current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_AWF_Sample(TBuffer &buf, void *obj) {
      ((::AWF_Sample*)obj)->::AWF_Sample::Streamer(buf);
   }
} // end of namespace ROOT for class ::AWF_Sample

namespace ROOT {
   // Wrappers around operator new
   static void *new_DWF_Sample(void *p) {
      return  p ? new(p) ::DWF_Sample : new ::DWF_Sample;
   }
   static void *newArray_DWF_Sample(Long_t nElements, void *p) {
      return p ? new(p) ::DWF_Sample[nElements] : new ::DWF_Sample[nElements];
   }
   // Wrapper around operator delete
   static void delete_DWF_Sample(void *p) {
      delete ((::DWF_Sample*)p);
   }
   static void deleteArray_DWF_Sample(void *p) {
      delete [] ((::DWF_Sample*)p);
   }
   static void destruct_DWF_Sample(void *p) {
      typedef ::DWF_Sample current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_DWF_Sample(TBuffer &buf, void *obj) {
      ((::DWF_Sample*)obj)->::DWF_Sample::Streamer(buf);
   }
} // end of namespace ROOT for class ::DWF_Sample

namespace ROOT {
   // Wrappers around operator new
   static void *new_WF_Header(void *p) {
      return  p ? new(p) ::WF_Header : new ::WF_Header;
   }
   static void *newArray_WF_Header(Long_t nElements, void *p) {
      return p ? new(p) ::WF_Header[nElements] : new ::WF_Header[nElements];
   }
   // Wrapper around operator delete
   static void delete_WF_Header(void *p) {
      delete ((::WF_Header*)p);
   }
   static void deleteArray_WF_Header(void *p) {
      delete [] ((::WF_Header*)p);
   }
   static void destruct_WF_Header(void *p) {
      typedef ::WF_Header current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_WF_Header(TBuffer &buf, void *obj) {
      ((::WF_Header*)obj)->::WF_Header::Streamer(buf);
   }
} // end of namespace ROOT for class ::WF_Header

namespace ROOT {
   // Wrappers around operator new
   static void *new_WF_ItemlEAWF_SamplegR(void *p) {
      return  p ? new(p) ::WF_Item<AWF_Sample> : new ::WF_Item<AWF_Sample>;
   }
   static void *newArray_WF_ItemlEAWF_SamplegR(Long_t nElements, void *p) {
      return p ? new(p) ::WF_Item<AWF_Sample>[nElements] : new ::WF_Item<AWF_Sample>[nElements];
   }
   // Wrapper around operator delete
   static void delete_WF_ItemlEAWF_SamplegR(void *p) {
      delete ((::WF_Item<AWF_Sample>*)p);
   }
   static void deleteArray_WF_ItemlEAWF_SamplegR(void *p) {
      delete [] ((::WF_Item<AWF_Sample>*)p);
   }
   static void destruct_WF_ItemlEAWF_SamplegR(void *p) {
      typedef ::WF_Item<AWF_Sample> current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_WF_ItemlEAWF_SamplegR(TBuffer &buf, void *obj) {
      ((::WF_Item<AWF_Sample>*)obj)->::WF_Item<AWF_Sample>::Streamer(buf);
   }
} // end of namespace ROOT for class ::WF_Item<AWF_Sample>

namespace ROOT {
   // Wrappers around operator new
   static void *new_WF_ItemlEDWF_SamplegR(void *p) {
      return  p ? new(p) ::WF_Item<DWF_Sample> : new ::WF_Item<DWF_Sample>;
   }
   static void *newArray_WF_ItemlEDWF_SamplegR(Long_t nElements, void *p) {
      return p ? new(p) ::WF_Item<DWF_Sample>[nElements] : new ::WF_Item<DWF_Sample>[nElements];
   }
   // Wrapper around operator delete
   static void delete_WF_ItemlEDWF_SamplegR(void *p) {
      delete ((::WF_Item<DWF_Sample>*)p);
   }
   static void deleteArray_WF_ItemlEDWF_SamplegR(void *p) {
      delete [] ((::WF_Item<DWF_Sample>*)p);
   }
   static void destruct_WF_ItemlEDWF_SamplegR(void *p) {
      typedef ::WF_Item<DWF_Sample> current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_WF_ItemlEDWF_SamplegR(TBuffer &buf, void *obj) {
      ((::WF_Item<DWF_Sample>*)obj)->::WF_Item<DWF_Sample>::Streamer(buf);
   }
} // end of namespace ROOT for class ::WF_Item<DWF_Sample>

namespace ROOT {
   // Wrappers around operator new
   static void *new_AWF_Item(void *p) {
      return  p ? new(p) ::AWF_Item : new ::AWF_Item;
   }
   static void *newArray_AWF_Item(Long_t nElements, void *p) {
      return p ? new(p) ::AWF_Item[nElements] : new ::AWF_Item[nElements];
   }
   // Wrapper around operator delete
   static void delete_AWF_Item(void *p) {
      delete ((::AWF_Item*)p);
   }
   static void deleteArray_AWF_Item(void *p) {
      delete [] ((::AWF_Item*)p);
   }
   static void destruct_AWF_Item(void *p) {
      typedef ::AWF_Item current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_AWF_Item(TBuffer &buf, void *obj) {
      ((::AWF_Item*)obj)->::AWF_Item::Streamer(buf);
   }
} // end of namespace ROOT for class ::AWF_Item

namespace ROOT {
   // Wrappers around operator new
   static void *new_DWF_Item(void *p) {
      return  p ? new(p) ::DWF_Item : new ::DWF_Item;
   }
   static void *newArray_DWF_Item(Long_t nElements, void *p) {
      return p ? new(p) ::DWF_Item[nElements] : new ::DWF_Item[nElements];
   }
   // Wrapper around operator delete
   static void delete_DWF_Item(void *p) {
      delete ((::DWF_Item*)p);
   }
   static void deleteArray_DWF_Item(void *p) {
      delete [] ((::DWF_Item*)p);
   }
   static void destruct_DWF_Item(void *p) {
      typedef ::DWF_Item current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_DWF_Item(TBuffer &buf, void *obj) {
      ((::DWF_Item*)obj)->::DWF_Item::Streamer(buf);
   }
} // end of namespace ROOT for class ::DWF_Item

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

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_DaqFramePreamble(void *p) {
      return  p ? new(p) ::DaqFramePreamble : new ::DaqFramePreamble;
   }
   static void *newArray_DaqFramePreamble(Long_t nElements, void *p) {
      return p ? new(p) ::DaqFramePreamble[nElements] : new ::DaqFramePreamble[nElements];
   }
   // Wrapper around operator delete
   static void delete_DaqFramePreamble(void *p) {
      delete ((::DaqFramePreamble*)p);
   }
   static void deleteArray_DaqFramePreamble(void *p) {
      delete [] ((::DaqFramePreamble*)p);
   }
   static void destruct_DaqFramePreamble(void *p) {
      typedef ::DaqFramePreamble current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::DaqFramePreamble

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

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_EventPreamble(void *p) {
      return  p ? new(p) ::EventPreamble : new ::EventPreamble;
   }
   static void *newArray_EventPreamble(Long_t nElements, void *p) {
      return p ? new(p) ::EventPreamble[nElements] : new ::EventPreamble[nElements];
   }
   // Wrapper around operator delete
   static void delete_EventPreamble(void *p) {
      delete ((::EventPreamble*)p);
   }
   static void deleteArray_EventPreamble(void *p) {
      delete [] ((::EventPreamble*)p);
   }
   static void destruct_EventPreamble(void *p) {
      typedef ::EventPreamble current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::EventPreamble

namespace ROOT {
   // Wrappers around operator new
   static void *new_Summary_Frame(void *p) {
      return  p ? new(p) ::Summary_Frame : new ::Summary_Frame;
   }
   static void *newArray_Summary_Frame(Long_t nElements, void *p) {
      return p ? new(p) ::Summary_Frame[nElements] : new ::Summary_Frame[nElements];
   }
   // Wrapper around operator delete
   static void delete_Summary_Frame(void *p) {
      delete ((::Summary_Frame*)p);
   }
   static void deleteArray_Summary_Frame(void *p) {
      delete [] ((::Summary_Frame*)p);
   }
   static void destruct_Summary_Frame(void *p) {
      typedef ::Summary_Frame current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_Summary_Frame(TBuffer &buf, void *obj) {
      ((::Summary_Frame*)obj)->::Summary_Frame::Streamer(buf);
   }
} // end of namespace ROOT for class ::Summary_Frame

namespace ROOT {
   // Wrappers around operator new
   static void *new_ExtendedSummary_Frame(void *p) {
      return  p ? new(p) ::ExtendedSummary_Frame : new ::ExtendedSummary_Frame;
   }
   static void *newArray_ExtendedSummary_Frame(Long_t nElements, void *p) {
      return p ? new(p) ::ExtendedSummary_Frame[nElements] : new ::ExtendedSummary_Frame[nElements];
   }
   // Wrapper around operator delete
   static void delete_ExtendedSummary_Frame(void *p) {
      delete ((::ExtendedSummary_Frame*)p);
   }
   static void deleteArray_ExtendedSummary_Frame(void *p) {
      delete [] ((::ExtendedSummary_Frame*)p);
   }
   static void destruct_ExtendedSummary_Frame(void *p) {
      typedef ::ExtendedSummary_Frame current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_ExtendedSummary_Frame(TBuffer &buf, void *obj) {
      ((::ExtendedSummary_Frame*)obj)->::ExtendedSummary_Frame::Streamer(buf);
   }
} // end of namespace ROOT for class ::ExtendedSummary_Frame

//______________________________________________________________________________
template <> void Frame<Status_Item>::Streamer(TBuffer &R__b)
{
   // Stream an object of class Frame<Status_Item>.

   if (R__b.IsReading()) {
      R__b.ReadClassBuffer(Frame<Status_Item>::Class(),this);
   } else {
      R__b.WriteClassBuffer(Frame<Status_Item>::Class(),this);
   }
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_FramelEStatus_ItemgR(void *p) {
      return  p ? new(p) ::Frame<Status_Item> : new ::Frame<Status_Item>;
   }
   static void *newArray_FramelEStatus_ItemgR(Long_t nElements, void *p) {
      return p ? new(p) ::Frame<Status_Item>[nElements] : new ::Frame<Status_Item>[nElements];
   }
   // Wrapper around operator delete
   static void delete_FramelEStatus_ItemgR(void *p) {
      delete ((::Frame<Status_Item>*)p);
   }
   static void deleteArray_FramelEStatus_ItemgR(void *p) {
      delete [] ((::Frame<Status_Item>*)p);
   }
   static void destruct_FramelEStatus_ItemgR(void *p) {
      typedef ::Frame<Status_Item> current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::Frame<Status_Item>

//______________________________________________________________________________
template <> void Frame<RTS_Item>::Streamer(TBuffer &R__b)
{
   // Stream an object of class Frame<RTS_Item>.

   if (R__b.IsReading()) {
      R__b.ReadClassBuffer(Frame<RTS_Item>::Class(),this);
   } else {
      R__b.WriteClassBuffer(Frame<RTS_Item>::Class(),this);
   }
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_FramelERTS_ItemgR(void *p) {
      return  p ? new(p) ::Frame<RTS_Item> : new ::Frame<RTS_Item>;
   }
   static void *newArray_FramelERTS_ItemgR(Long_t nElements, void *p) {
      return p ? new(p) ::Frame<RTS_Item>[nElements] : new ::Frame<RTS_Item>[nElements];
   }
   // Wrapper around operator delete
   static void delete_FramelERTS_ItemgR(void *p) {
      delete ((::Frame<RTS_Item>*)p);
   }
   static void deleteArray_FramelERTS_ItemgR(void *p) {
      delete [] ((::Frame<RTS_Item>*)p);
   }
   static void destruct_FramelERTS_ItemgR(void *p) {
      typedef ::Frame<RTS_Item> current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::Frame<RTS_Item>

//______________________________________________________________________________
template <> void Frame<CRM_Item>::Streamer(TBuffer &R__b)
{
   // Stream an object of class Frame<CRM_Item>.

   if (R__b.IsReading()) {
      R__b.ReadClassBuffer(Frame<CRM_Item>::Class(),this);
   } else {
      R__b.WriteClassBuffer(Frame<CRM_Item>::Class(),this);
   }
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_FramelECRM_ItemgR(void *p) {
      return  p ? new(p) ::Frame<CRM_Item> : new ::Frame<CRM_Item>;
   }
   static void *newArray_FramelECRM_ItemgR(Long_t nElements, void *p) {
      return p ? new(p) ::Frame<CRM_Item>[nElements] : new ::Frame<CRM_Item>[nElements];
   }
   // Wrapper around operator delete
   static void delete_FramelECRM_ItemgR(void *p) {
      delete ((::Frame<CRM_Item>*)p);
   }
   static void deleteArray_FramelECRM_ItemgR(void *p) {
      delete [] ((::Frame<CRM_Item>*)p);
   }
   static void destruct_FramelECRM_ItemgR(void *p) {
      typedef ::Frame<CRM_Item> current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::Frame<CRM_Item>

//______________________________________________________________________________
template <> void Frame<SPE_Item>::Streamer(TBuffer &R__b)
{
   // Stream an object of class Frame<SPE_Item>.

   if (R__b.IsReading()) {
      R__b.ReadClassBuffer(Frame<SPE_Item>::Class(),this);
   } else {
      R__b.WriteClassBuffer(Frame<SPE_Item>::Class(),this);
   }
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_FramelESPE_ItemgR(void *p) {
      return  p ? new(p) ::Frame<SPE_Item> : new ::Frame<SPE_Item>;
   }
   static void *newArray_FramelESPE_ItemgR(Long_t nElements, void *p) {
      return p ? new(p) ::Frame<SPE_Item>[nElements] : new ::Frame<SPE_Item>[nElements];
   }
   // Wrapper around operator delete
   static void delete_FramelESPE_ItemgR(void *p) {
      delete ((::Frame<SPE_Item>*)p);
   }
   static void deleteArray_FramelESPE_ItemgR(void *p) {
      delete [] ((::Frame<SPE_Item>*)p);
   }
   static void destruct_FramelESPE_ItemgR(void *p) {
      typedef ::Frame<SPE_Item> current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::Frame<SPE_Item>

//______________________________________________________________________________
template <> void Frame<AWF_Item>::Streamer(TBuffer &R__b)
{
   // Stream an object of class Frame<AWF_Item>.

   if (R__b.IsReading()) {
      R__b.ReadClassBuffer(Frame<AWF_Item>::Class(),this);
   } else {
      R__b.WriteClassBuffer(Frame<AWF_Item>::Class(),this);
   }
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_FramelEAWF_ItemgR(void *p) {
      return  p ? new(p) ::Frame<AWF_Item> : new ::Frame<AWF_Item>;
   }
   static void *newArray_FramelEAWF_ItemgR(Long_t nElements, void *p) {
      return p ? new(p) ::Frame<AWF_Item>[nElements] : new ::Frame<AWF_Item>[nElements];
   }
   // Wrapper around operator delete
   static void delete_FramelEAWF_ItemgR(void *p) {
      delete ((::Frame<AWF_Item>*)p);
   }
   static void deleteArray_FramelEAWF_ItemgR(void *p) {
      delete [] ((::Frame<AWF_Item>*)p);
   }
   static void destruct_FramelEAWF_ItemgR(void *p) {
      typedef ::Frame<AWF_Item> current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::Frame<AWF_Item>

//______________________________________________________________________________
template <> void Frame<DWF_Item>::Streamer(TBuffer &R__b)
{
   // Stream an object of class Frame<DWF_Item>.

   if (R__b.IsReading()) {
      R__b.ReadClassBuffer(Frame<DWF_Item>::Class(),this);
   } else {
      R__b.WriteClassBuffer(Frame<DWF_Item>::Class(),this);
   }
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_FramelEDWF_ItemgR(void *p) {
      return  p ? new(p) ::Frame<DWF_Item> : new ::Frame<DWF_Item>;
   }
   static void *newArray_FramelEDWF_ItemgR(Long_t nElements, void *p) {
      return p ? new(p) ::Frame<DWF_Item>[nElements] : new ::Frame<DWF_Item>[nElements];
   }
   // Wrapper around operator delete
   static void delete_FramelEDWF_ItemgR(void *p) {
      delete ((::Frame<DWF_Item>*)p);
   }
   static void deleteArray_FramelEDWF_ItemgR(void *p) {
      delete [] ((::Frame<DWF_Item>*)p);
   }
   static void destruct_FramelEDWF_ItemgR(void *p) {
      typedef ::Frame<DWF_Item> current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::Frame<DWF_Item>

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

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_Status_Frame(void *p) {
      return  p ? new(p) ::Status_Frame : new ::Status_Frame;
   }
   static void *newArray_Status_Frame(Long_t nElements, void *p) {
      return p ? new(p) ::Status_Frame[nElements] : new ::Status_Frame[nElements];
   }
   // Wrapper around operator delete
   static void delete_Status_Frame(void *p) {
      delete ((::Status_Frame*)p);
   }
   static void deleteArray_Status_Frame(void *p) {
      delete [] ((::Status_Frame*)p);
   }
   static void destruct_Status_Frame(void *p) {
      typedef ::Status_Frame current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::Status_Frame

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

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_RTS_Frame(void *p) {
      return  p ? new(p) ::RTS_Frame : new ::RTS_Frame;
   }
   static void *newArray_RTS_Frame(Long_t nElements, void *p) {
      return p ? new(p) ::RTS_Frame[nElements] : new ::RTS_Frame[nElements];
   }
   // Wrapper around operator delete
   static void delete_RTS_Frame(void *p) {
      delete ((::RTS_Frame*)p);
   }
   static void deleteArray_RTS_Frame(void *p) {
      delete [] ((::RTS_Frame*)p);
   }
   static void destruct_RTS_Frame(void *p) {
      typedef ::RTS_Frame current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::RTS_Frame

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

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_CRM_Frame(void *p) {
      return  p ? new(p) ::CRM_Frame : new ::CRM_Frame;
   }
   static void *newArray_CRM_Frame(Long_t nElements, void *p) {
      return p ? new(p) ::CRM_Frame[nElements] : new ::CRM_Frame[nElements];
   }
   // Wrapper around operator delete
   static void delete_CRM_Frame(void *p) {
      delete ((::CRM_Frame*)p);
   }
   static void deleteArray_CRM_Frame(void *p) {
      delete [] ((::CRM_Frame*)p);
   }
   static void destruct_CRM_Frame(void *p) {
      typedef ::CRM_Frame current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::CRM_Frame

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

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_SPE_Frame(void *p) {
      return  p ? new(p) ::SPE_Frame : new ::SPE_Frame;
   }
   static void *newArray_SPE_Frame(Long_t nElements, void *p) {
      return p ? new(p) ::SPE_Frame[nElements] : new ::SPE_Frame[nElements];
   }
   // Wrapper around operator delete
   static void delete_SPE_Frame(void *p) {
      delete ((::SPE_Frame*)p);
   }
   static void deleteArray_SPE_Frame(void *p) {
      delete [] ((::SPE_Frame*)p);
   }
   static void destruct_SPE_Frame(void *p) {
      typedef ::SPE_Frame current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::SPE_Frame

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

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_AWF_Frame(void *p) {
      return  p ? new(p) ::AWF_Frame : new ::AWF_Frame;
   }
   static void *newArray_AWF_Frame(Long_t nElements, void *p) {
      return p ? new(p) ::AWF_Frame[nElements] : new ::AWF_Frame[nElements];
   }
   // Wrapper around operator delete
   static void delete_AWF_Frame(void *p) {
      delete ((::AWF_Frame*)p);
   }
   static void deleteArray_AWF_Frame(void *p) {
      delete [] ((::AWF_Frame*)p);
   }
   static void destruct_AWF_Frame(void *p) {
      typedef ::AWF_Frame current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::AWF_Frame

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

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_DWF_Frame(void *p) {
      return  p ? new(p) ::DWF_Frame : new ::DWF_Frame;
   }
   static void *newArray_DWF_Frame(Long_t nElements, void *p) {
      return p ? new(p) ::DWF_Frame[nElements] : new ::DWF_Frame[nElements];
   }
   // Wrapper around operator delete
   static void delete_DWF_Frame(void *p) {
      delete ((::DWF_Frame*)p);
   }
   static void deleteArray_DWF_Frame(void *p) {
      delete [] ((::DWF_Frame*)p);
   }
   static void destruct_DWF_Frame(void *p) {
      typedef ::DWF_Frame current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::DWF_Frame

//______________________________________________________________________________
template <> void TimeSlice<Status_Frame>::Streamer(TBuffer &R__b)
{
   // Stream an object of class TimeSlice<Status_Frame>.

   if (R__b.IsReading()) {
      R__b.ReadClassBuffer(TimeSlice<Status_Frame>::Class(),this);
   } else {
      R__b.WriteClassBuffer(TimeSlice<Status_Frame>::Class(),this);
   }
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TimeSlicelEStatus_FramegR(void *p) {
      return  p ? new(p) ::TimeSlice<Status_Frame> : new ::TimeSlice<Status_Frame>;
   }
   static void *newArray_TimeSlicelEStatus_FramegR(Long_t nElements, void *p) {
      return p ? new(p) ::TimeSlice<Status_Frame>[nElements] : new ::TimeSlice<Status_Frame>[nElements];
   }
   // Wrapper around operator delete
   static void delete_TimeSlicelEStatus_FramegR(void *p) {
      delete ((::TimeSlice<Status_Frame>*)p);
   }
   static void deleteArray_TimeSlicelEStatus_FramegR(void *p) {
      delete [] ((::TimeSlice<Status_Frame>*)p);
   }
   static void destruct_TimeSlicelEStatus_FramegR(void *p) {
      typedef ::TimeSlice<Status_Frame> current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TimeSlice<Status_Frame>

//______________________________________________________________________________
template <> void TimeSlice<RTS_Frame>::Streamer(TBuffer &R__b)
{
   // Stream an object of class TimeSlice<RTS_Frame>.

   if (R__b.IsReading()) {
      R__b.ReadClassBuffer(TimeSlice<RTS_Frame>::Class(),this);
   } else {
      R__b.WriteClassBuffer(TimeSlice<RTS_Frame>::Class(),this);
   }
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TimeSlicelERTS_FramegR(void *p) {
      return  p ? new(p) ::TimeSlice<RTS_Frame> : new ::TimeSlice<RTS_Frame>;
   }
   static void *newArray_TimeSlicelERTS_FramegR(Long_t nElements, void *p) {
      return p ? new(p) ::TimeSlice<RTS_Frame>[nElements] : new ::TimeSlice<RTS_Frame>[nElements];
   }
   // Wrapper around operator delete
   static void delete_TimeSlicelERTS_FramegR(void *p) {
      delete ((::TimeSlice<RTS_Frame>*)p);
   }
   static void deleteArray_TimeSlicelERTS_FramegR(void *p) {
      delete [] ((::TimeSlice<RTS_Frame>*)p);
   }
   static void destruct_TimeSlicelERTS_FramegR(void *p) {
      typedef ::TimeSlice<RTS_Frame> current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TimeSlice<RTS_Frame>

//______________________________________________________________________________
template <> void TimeSlice<CRM_Frame>::Streamer(TBuffer &R__b)
{
   // Stream an object of class TimeSlice<CRM_Frame>.

   if (R__b.IsReading()) {
      R__b.ReadClassBuffer(TimeSlice<CRM_Frame>::Class(),this);
   } else {
      R__b.WriteClassBuffer(TimeSlice<CRM_Frame>::Class(),this);
   }
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TimeSlicelECRM_FramegR(void *p) {
      return  p ? new(p) ::TimeSlice<CRM_Frame> : new ::TimeSlice<CRM_Frame>;
   }
   static void *newArray_TimeSlicelECRM_FramegR(Long_t nElements, void *p) {
      return p ? new(p) ::TimeSlice<CRM_Frame>[nElements] : new ::TimeSlice<CRM_Frame>[nElements];
   }
   // Wrapper around operator delete
   static void delete_TimeSlicelECRM_FramegR(void *p) {
      delete ((::TimeSlice<CRM_Frame>*)p);
   }
   static void deleteArray_TimeSlicelECRM_FramegR(void *p) {
      delete [] ((::TimeSlice<CRM_Frame>*)p);
   }
   static void destruct_TimeSlicelECRM_FramegR(void *p) {
      typedef ::TimeSlice<CRM_Frame> current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TimeSlice<CRM_Frame>

//______________________________________________________________________________
template <> void TimeSlice<SPE_Frame>::Streamer(TBuffer &R__b)
{
   // Stream an object of class TimeSlice<SPE_Frame>.

   if (R__b.IsReading()) {
      R__b.ReadClassBuffer(TimeSlice<SPE_Frame>::Class(),this);
   } else {
      R__b.WriteClassBuffer(TimeSlice<SPE_Frame>::Class(),this);
   }
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TimeSlicelESPE_FramegR(void *p) {
      return  p ? new(p) ::TimeSlice<SPE_Frame> : new ::TimeSlice<SPE_Frame>;
   }
   static void *newArray_TimeSlicelESPE_FramegR(Long_t nElements, void *p) {
      return p ? new(p) ::TimeSlice<SPE_Frame>[nElements] : new ::TimeSlice<SPE_Frame>[nElements];
   }
   // Wrapper around operator delete
   static void delete_TimeSlicelESPE_FramegR(void *p) {
      delete ((::TimeSlice<SPE_Frame>*)p);
   }
   static void deleteArray_TimeSlicelESPE_FramegR(void *p) {
      delete [] ((::TimeSlice<SPE_Frame>*)p);
   }
   static void destruct_TimeSlicelESPE_FramegR(void *p) {
      typedef ::TimeSlice<SPE_Frame> current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TimeSlice<SPE_Frame>

//______________________________________________________________________________
template <> void TimeSlice<AWF_Frame>::Streamer(TBuffer &R__b)
{
   // Stream an object of class TimeSlice<AWF_Frame>.

   if (R__b.IsReading()) {
      R__b.ReadClassBuffer(TimeSlice<AWF_Frame>::Class(),this);
   } else {
      R__b.WriteClassBuffer(TimeSlice<AWF_Frame>::Class(),this);
   }
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TimeSlicelEAWF_FramegR(void *p) {
      return  p ? new(p) ::TimeSlice<AWF_Frame> : new ::TimeSlice<AWF_Frame>;
   }
   static void *newArray_TimeSlicelEAWF_FramegR(Long_t nElements, void *p) {
      return p ? new(p) ::TimeSlice<AWF_Frame>[nElements] : new ::TimeSlice<AWF_Frame>[nElements];
   }
   // Wrapper around operator delete
   static void delete_TimeSlicelEAWF_FramegR(void *p) {
      delete ((::TimeSlice<AWF_Frame>*)p);
   }
   static void deleteArray_TimeSlicelEAWF_FramegR(void *p) {
      delete [] ((::TimeSlice<AWF_Frame>*)p);
   }
   static void destruct_TimeSlicelEAWF_FramegR(void *p) {
      typedef ::TimeSlice<AWF_Frame> current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TimeSlice<AWF_Frame>

//______________________________________________________________________________
template <> void TimeSlice<DWF_Frame>::Streamer(TBuffer &R__b)
{
   // Stream an object of class TimeSlice<DWF_Frame>.

   if (R__b.IsReading()) {
      R__b.ReadClassBuffer(TimeSlice<DWF_Frame>::Class(),this);
   } else {
      R__b.WriteClassBuffer(TimeSlice<DWF_Frame>::Class(),this);
   }
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TimeSlicelEDWF_FramegR(void *p) {
      return  p ? new(p) ::TimeSlice<DWF_Frame> : new ::TimeSlice<DWF_Frame>;
   }
   static void *newArray_TimeSlicelEDWF_FramegR(Long_t nElements, void *p) {
      return p ? new(p) ::TimeSlice<DWF_Frame>[nElements] : new ::TimeSlice<DWF_Frame>[nElements];
   }
   // Wrapper around operator delete
   static void delete_TimeSlicelEDWF_FramegR(void *p) {
      delete ((::TimeSlice<DWF_Frame>*)p);
   }
   static void deleteArray_TimeSlicelEDWF_FramegR(void *p) {
      delete [] ((::TimeSlice<DWF_Frame>*)p);
   }
   static void destruct_TimeSlicelEDWF_FramegR(void *p) {
      typedef ::TimeSlice<DWF_Frame> current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TimeSlice<DWF_Frame>

//______________________________________________________________________________
template <> void TimeSlice<Summary_Frame>::Streamer(TBuffer &R__b)
{
   // Stream an object of class TimeSlice<Summary_Frame>.

   if (R__b.IsReading()) {
      R__b.ReadClassBuffer(TimeSlice<Summary_Frame>::Class(),this);
   } else {
      R__b.WriteClassBuffer(TimeSlice<Summary_Frame>::Class(),this);
   }
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TimeSlicelESummary_FramegR(void *p) {
      return  p ? new(p) ::TimeSlice<Summary_Frame> : new ::TimeSlice<Summary_Frame>;
   }
   static void *newArray_TimeSlicelESummary_FramegR(Long_t nElements, void *p) {
      return p ? new(p) ::TimeSlice<Summary_Frame>[nElements] : new ::TimeSlice<Summary_Frame>[nElements];
   }
   // Wrapper around operator delete
   static void delete_TimeSlicelESummary_FramegR(void *p) {
      delete ((::TimeSlice<Summary_Frame>*)p);
   }
   static void deleteArray_TimeSlicelESummary_FramegR(void *p) {
      delete [] ((::TimeSlice<Summary_Frame>*)p);
   }
   static void destruct_TimeSlicelESummary_FramegR(void *p) {
      typedef ::TimeSlice<Summary_Frame> current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TimeSlice<Summary_Frame>

//______________________________________________________________________________
template <> void TimeSlice<ExtendedSummary_Frame>::Streamer(TBuffer &R__b)
{
   // Stream an object of class TimeSlice<ExtendedSummary_Frame>.

   if (R__b.IsReading()) {
      R__b.ReadClassBuffer(TimeSlice<ExtendedSummary_Frame>::Class(),this);
   } else {
      R__b.WriteClassBuffer(TimeSlice<ExtendedSummary_Frame>::Class(),this);
   }
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TimeSlicelEExtendedSummary_FramegR(void *p) {
      return  p ? new(p) ::TimeSlice<ExtendedSummary_Frame> : new ::TimeSlice<ExtendedSummary_Frame>;
   }
   static void *newArray_TimeSlicelEExtendedSummary_FramegR(Long_t nElements, void *p) {
      return p ? new(p) ::TimeSlice<ExtendedSummary_Frame>[nElements] : new ::TimeSlice<ExtendedSummary_Frame>[nElements];
   }
   // Wrapper around operator delete
   static void delete_TimeSlicelEExtendedSummary_FramegR(void *p) {
      delete ((::TimeSlice<ExtendedSummary_Frame>*)p);
   }
   static void deleteArray_TimeSlicelEExtendedSummary_FramegR(void *p) {
      delete [] ((::TimeSlice<ExtendedSummary_Frame>*)p);
   }
   static void destruct_TimeSlicelEExtendedSummary_FramegR(void *p) {
      typedef ::TimeSlice<ExtendedSummary_Frame> current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TimeSlice<ExtendedSummary_Frame>

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

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_Status_TimeSlice(void *p) {
      return  p ? new(p) ::Status_TimeSlice : new ::Status_TimeSlice;
   }
   static void *newArray_Status_TimeSlice(Long_t nElements, void *p) {
      return p ? new(p) ::Status_TimeSlice[nElements] : new ::Status_TimeSlice[nElements];
   }
   // Wrapper around operator delete
   static void delete_Status_TimeSlice(void *p) {
      delete ((::Status_TimeSlice*)p);
   }
   static void deleteArray_Status_TimeSlice(void *p) {
      delete [] ((::Status_TimeSlice*)p);
   }
   static void destruct_Status_TimeSlice(void *p) {
      typedef ::Status_TimeSlice current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::Status_TimeSlice

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

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_RTS_TimeSlice(void *p) {
      return  p ? new(p) ::RTS_TimeSlice : new ::RTS_TimeSlice;
   }
   static void *newArray_RTS_TimeSlice(Long_t nElements, void *p) {
      return p ? new(p) ::RTS_TimeSlice[nElements] : new ::RTS_TimeSlice[nElements];
   }
   // Wrapper around operator delete
   static void delete_RTS_TimeSlice(void *p) {
      delete ((::RTS_TimeSlice*)p);
   }
   static void deleteArray_RTS_TimeSlice(void *p) {
      delete [] ((::RTS_TimeSlice*)p);
   }
   static void destruct_RTS_TimeSlice(void *p) {
      typedef ::RTS_TimeSlice current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::RTS_TimeSlice

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

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_CRM_TimeSlice(void *p) {
      return  p ? new(p) ::CRM_TimeSlice : new ::CRM_TimeSlice;
   }
   static void *newArray_CRM_TimeSlice(Long_t nElements, void *p) {
      return p ? new(p) ::CRM_TimeSlice[nElements] : new ::CRM_TimeSlice[nElements];
   }
   // Wrapper around operator delete
   static void delete_CRM_TimeSlice(void *p) {
      delete ((::CRM_TimeSlice*)p);
   }
   static void deleteArray_CRM_TimeSlice(void *p) {
      delete [] ((::CRM_TimeSlice*)p);
   }
   static void destruct_CRM_TimeSlice(void *p) {
      typedef ::CRM_TimeSlice current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::CRM_TimeSlice

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

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_SPE_TimeSlice(void *p) {
      return  p ? new(p) ::SPE_TimeSlice : new ::SPE_TimeSlice;
   }
   static void *newArray_SPE_TimeSlice(Long_t nElements, void *p) {
      return p ? new(p) ::SPE_TimeSlice[nElements] : new ::SPE_TimeSlice[nElements];
   }
   // Wrapper around operator delete
   static void delete_SPE_TimeSlice(void *p) {
      delete ((::SPE_TimeSlice*)p);
   }
   static void deleteArray_SPE_TimeSlice(void *p) {
      delete [] ((::SPE_TimeSlice*)p);
   }
   static void destruct_SPE_TimeSlice(void *p) {
      typedef ::SPE_TimeSlice current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::SPE_TimeSlice

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

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_AWF_TimeSlice(void *p) {
      return  p ? new(p) ::AWF_TimeSlice : new ::AWF_TimeSlice;
   }
   static void *newArray_AWF_TimeSlice(Long_t nElements, void *p) {
      return p ? new(p) ::AWF_TimeSlice[nElements] : new ::AWF_TimeSlice[nElements];
   }
   // Wrapper around operator delete
   static void delete_AWF_TimeSlice(void *p) {
      delete ((::AWF_TimeSlice*)p);
   }
   static void deleteArray_AWF_TimeSlice(void *p) {
      delete [] ((::AWF_TimeSlice*)p);
   }
   static void destruct_AWF_TimeSlice(void *p) {
      typedef ::AWF_TimeSlice current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::AWF_TimeSlice

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

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_DWF_TimeSlice(void *p) {
      return  p ? new(p) ::DWF_TimeSlice : new ::DWF_TimeSlice;
   }
   static void *newArray_DWF_TimeSlice(Long_t nElements, void *p) {
      return p ? new(p) ::DWF_TimeSlice[nElements] : new ::DWF_TimeSlice[nElements];
   }
   // Wrapper around operator delete
   static void delete_DWF_TimeSlice(void *p) {
      delete ((::DWF_TimeSlice*)p);
   }
   static void deleteArray_DWF_TimeSlice(void *p) {
      delete [] ((::DWF_TimeSlice*)p);
   }
   static void destruct_DWF_TimeSlice(void *p) {
      typedef ::DWF_TimeSlice current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::DWF_TimeSlice

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

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_Summary_TimeSlice(void *p) {
      return  p ? new(p) ::Summary_TimeSlice : new ::Summary_TimeSlice;
   }
   static void *newArray_Summary_TimeSlice(Long_t nElements, void *p) {
      return p ? new(p) ::Summary_TimeSlice[nElements] : new ::Summary_TimeSlice[nElements];
   }
   // Wrapper around operator delete
   static void delete_Summary_TimeSlice(void *p) {
      delete ((::Summary_TimeSlice*)p);
   }
   static void deleteArray_Summary_TimeSlice(void *p) {
      delete [] ((::Summary_TimeSlice*)p);
   }
   static void destruct_Summary_TimeSlice(void *p) {
      typedef ::Summary_TimeSlice current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::Summary_TimeSlice

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

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_ExtendedSummary_TimeSlice(void *p) {
      return  p ? new(p) ::ExtendedSummary_TimeSlice : new ::ExtendedSummary_TimeSlice;
   }
   static void *newArray_ExtendedSummary_TimeSlice(Long_t nElements, void *p) {
      return p ? new(p) ::ExtendedSummary_TimeSlice[nElements] : new ::ExtendedSummary_TimeSlice[nElements];
   }
   // Wrapper around operator delete
   static void delete_ExtendedSummary_TimeSlice(void *p) {
      delete ((::ExtendedSummary_TimeSlice*)p);
   }
   static void deleteArray_ExtendedSummary_TimeSlice(void *p) {
      delete [] ((::ExtendedSummary_TimeSlice*)p);
   }
   static void destruct_ExtendedSummary_TimeSlice(void *p) {
      typedef ::ExtendedSummary_TimeSlice current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::ExtendedSummary_TimeSlice

namespace ROOT {
   // Wrappers around operator new
   static void *new_ARS_HitlESPE_ItemgR(void *p) {
      return  p ? new(p) ::ARS_Hit<SPE_Item> : new ::ARS_Hit<SPE_Item>;
   }
   static void *newArray_ARS_HitlESPE_ItemgR(Long_t nElements, void *p) {
      return p ? new(p) ::ARS_Hit<SPE_Item>[nElements] : new ::ARS_Hit<SPE_Item>[nElements];
   }
   // Wrapper around operator delete
   static void delete_ARS_HitlESPE_ItemgR(void *p) {
      delete ((::ARS_Hit<SPE_Item>*)p);
   }
   static void deleteArray_ARS_HitlESPE_ItemgR(void *p) {
      delete [] ((::ARS_Hit<SPE_Item>*)p);
   }
   static void destruct_ARS_HitlESPE_ItemgR(void *p) {
      typedef ::ARS_Hit<SPE_Item> current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_ARS_HitlESPE_ItemgR(TBuffer &buf, void *obj) {
      ((::ARS_Hit<SPE_Item>*)obj)->::ARS_Hit<SPE_Item>::Streamer(buf);
   }
} // end of namespace ROOT for class ::ARS_Hit<SPE_Item>

namespace ROOT {
   // Wrappers around operator new
   static void *new_ARS_HitlEAWF_ItemgR(void *p) {
      return  p ? new(p) ::ARS_Hit<AWF_Item> : new ::ARS_Hit<AWF_Item>;
   }
   static void *newArray_ARS_HitlEAWF_ItemgR(Long_t nElements, void *p) {
      return p ? new(p) ::ARS_Hit<AWF_Item>[nElements] : new ::ARS_Hit<AWF_Item>[nElements];
   }
   // Wrapper around operator delete
   static void delete_ARS_HitlEAWF_ItemgR(void *p) {
      delete ((::ARS_Hit<AWF_Item>*)p);
   }
   static void deleteArray_ARS_HitlEAWF_ItemgR(void *p) {
      delete [] ((::ARS_Hit<AWF_Item>*)p);
   }
   static void destruct_ARS_HitlEAWF_ItemgR(void *p) {
      typedef ::ARS_Hit<AWF_Item> current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_ARS_HitlEAWF_ItemgR(TBuffer &buf, void *obj) {
      ((::ARS_Hit<AWF_Item>*)obj)->::ARS_Hit<AWF_Item>::Streamer(buf);
   }
} // end of namespace ROOT for class ::ARS_Hit<AWF_Item>

namespace ROOT {
   // Wrappers around operator new
   static void *new_ARS_HitlEDWF_ItemgR(void *p) {
      return  p ? new(p) ::ARS_Hit<DWF_Item> : new ::ARS_Hit<DWF_Item>;
   }
   static void *newArray_ARS_HitlEDWF_ItemgR(Long_t nElements, void *p) {
      return p ? new(p) ::ARS_Hit<DWF_Item>[nElements] : new ::ARS_Hit<DWF_Item>[nElements];
   }
   // Wrapper around operator delete
   static void delete_ARS_HitlEDWF_ItemgR(void *p) {
      delete ((::ARS_Hit<DWF_Item>*)p);
   }
   static void deleteArray_ARS_HitlEDWF_ItemgR(void *p) {
      delete [] ((::ARS_Hit<DWF_Item>*)p);
   }
   static void destruct_ARS_HitlEDWF_ItemgR(void *p) {
      typedef ::ARS_Hit<DWF_Item> current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_ARS_HitlEDWF_ItemgR(TBuffer &buf, void *obj) {
      ((::ARS_Hit<DWF_Item>*)obj)->::ARS_Hit<DWF_Item>::Streamer(buf);
   }
} // end of namespace ROOT for class ::ARS_Hit<DWF_Item>

namespace ROOT {
   // Wrappers around operator new
   static void *new_SPE_Hit(void *p) {
      return  p ? new(p) ::SPE_Hit : new ::SPE_Hit;
   }
   static void *newArray_SPE_Hit(Long_t nElements, void *p) {
      return p ? new(p) ::SPE_Hit[nElements] : new ::SPE_Hit[nElements];
   }
   // Wrapper around operator delete
   static void delete_SPE_Hit(void *p) {
      delete ((::SPE_Hit*)p);
   }
   static void deleteArray_SPE_Hit(void *p) {
      delete [] ((::SPE_Hit*)p);
   }
   static void destruct_SPE_Hit(void *p) {
      typedef ::SPE_Hit current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_SPE_Hit(TBuffer &buf, void *obj) {
      ((::SPE_Hit*)obj)->::SPE_Hit::Streamer(buf);
   }
} // end of namespace ROOT for class ::SPE_Hit

namespace ROOT {
   // Wrappers around operator new
   static void *new_AWF_Hit(void *p) {
      return  p ? new(p) ::AWF_Hit : new ::AWF_Hit;
   }
   static void *newArray_AWF_Hit(Long_t nElements, void *p) {
      return p ? new(p) ::AWF_Hit[nElements] : new ::AWF_Hit[nElements];
   }
   // Wrapper around operator delete
   static void delete_AWF_Hit(void *p) {
      delete ((::AWF_Hit*)p);
   }
   static void deleteArray_AWF_Hit(void *p) {
      delete [] ((::AWF_Hit*)p);
   }
   static void destruct_AWF_Hit(void *p) {
      typedef ::AWF_Hit current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_AWF_Hit(TBuffer &buf, void *obj) {
      ((::AWF_Hit*)obj)->::AWF_Hit::Streamer(buf);
   }
} // end of namespace ROOT for class ::AWF_Hit

namespace ROOT {
   // Wrappers around operator new
   static void *new_DWF_Hit(void *p) {
      return  p ? new(p) ::DWF_Hit : new ::DWF_Hit;
   }
   static void *newArray_DWF_Hit(Long_t nElements, void *p) {
      return p ? new(p) ::DWF_Hit[nElements] : new ::DWF_Hit[nElements];
   }
   // Wrapper around operator delete
   static void delete_DWF_Hit(void *p) {
      delete ((::DWF_Hit*)p);
   }
   static void deleteArray_DWF_Hit(void *p) {
      delete [] ((::DWF_Hit*)p);
   }
   static void destruct_DWF_Hit(void *p) {
      typedef ::DWF_Hit current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_DWF_Hit(TBuffer &buf, void *obj) {
      ((::DWF_Hit*)obj)->::DWF_Hit::Streamer(buf);
   }
} // end of namespace ROOT for class ::DWF_Hit

namespace ROOT {
   // Wrappers around operator new
   static void *new_TriggeredSPE_Hit(void *p) {
      return  p ? new(p) ::TriggeredSPE_Hit : new ::TriggeredSPE_Hit;
   }
   static void *newArray_TriggeredSPE_Hit(Long_t nElements, void *p) {
      return p ? new(p) ::TriggeredSPE_Hit[nElements] : new ::TriggeredSPE_Hit[nElements];
   }
   // Wrapper around operator delete
   static void delete_TriggeredSPE_Hit(void *p) {
      delete ((::TriggeredSPE_Hit*)p);
   }
   static void deleteArray_TriggeredSPE_Hit(void *p) {
      delete [] ((::TriggeredSPE_Hit*)p);
   }
   static void destruct_TriggeredSPE_Hit(void *p) {
      typedef ::TriggeredSPE_Hit current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TriggeredSPE_Hit(TBuffer &buf, void *obj) {
      ((::TriggeredSPE_Hit*)obj)->::TriggeredSPE_Hit::Streamer(buf);
   }
} // end of namespace ROOT for class ::TriggeredSPE_Hit

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

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_PhysicsEvent(void *p) {
      return  p ? new(p) ::PhysicsEvent : new ::PhysicsEvent;
   }
   static void *newArray_PhysicsEvent(Long_t nElements, void *p) {
      return p ? new(p) ::PhysicsEvent[nElements] : new ::PhysicsEvent[nElements];
   }
   // Wrapper around operator delete
   static void delete_PhysicsEvent(void *p) {
      delete ((::PhysicsEvent*)p);
   }
   static void deleteArray_PhysicsEvent(void *p) {
      delete [] ((::PhysicsEvent*)p);
   }
   static void destruct_PhysicsEvent(void *p) {
      typedef ::PhysicsEvent current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::PhysicsEvent

namespace ROOT {
   static TClass *vectorlETriggeredSPE_HitgR_Dictionary();
   static void vectorlETriggeredSPE_HitgR_TClassManip(TClass*);
   static void *new_vectorlETriggeredSPE_HitgR(void *p = 0);
   static void *newArray_vectorlETriggeredSPE_HitgR(Long_t size, void *p);
   static void delete_vectorlETriggeredSPE_HitgR(void *p);
   static void deleteArray_vectorlETriggeredSPE_HitgR(void *p);
   static void destruct_vectorlETriggeredSPE_HitgR(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const vector<TriggeredSPE_Hit>*)
   {
      vector<TriggeredSPE_Hit> *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(vector<TriggeredSPE_Hit>));
      static ::ROOT::TGenericClassInfo 
         instance("vector<TriggeredSPE_Hit>", -2, "vector", 210,
                  typeid(vector<TriggeredSPE_Hit>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &vectorlETriggeredSPE_HitgR_Dictionary, isa_proxy, 4,
                  sizeof(vector<TriggeredSPE_Hit>) );
      instance.SetNew(&new_vectorlETriggeredSPE_HitgR);
      instance.SetNewArray(&newArray_vectorlETriggeredSPE_HitgR);
      instance.SetDelete(&delete_vectorlETriggeredSPE_HitgR);
      instance.SetDeleteArray(&deleteArray_vectorlETriggeredSPE_HitgR);
      instance.SetDestructor(&destruct_vectorlETriggeredSPE_HitgR);
      instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::Pushback< vector<TriggeredSPE_Hit> >()));

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

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

   static void vectorlETriggeredSPE_HitgR_TClassManip(TClass* ){
   }

} // end of namespace ROOT

namespace ROOT {
   // Wrappers around operator new
   static void *new_vectorlETriggeredSPE_HitgR(void *p) {
      return  p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) vector<TriggeredSPE_Hit> : new vector<TriggeredSPE_Hit>;
   }
   static void *newArray_vectorlETriggeredSPE_HitgR(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) vector<TriggeredSPE_Hit>[nElements] : new vector<TriggeredSPE_Hit>[nElements];
   }
   // Wrapper around operator delete
   static void delete_vectorlETriggeredSPE_HitgR(void *p) {
      delete ((vector<TriggeredSPE_Hit>*)p);
   }
   static void deleteArray_vectorlETriggeredSPE_HitgR(void *p) {
      delete [] ((vector<TriggeredSPE_Hit>*)p);
   }
   static void destruct_vectorlETriggeredSPE_HitgR(void *p) {
      typedef vector<TriggeredSPE_Hit> current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class vector<TriggeredSPE_Hit>

namespace ROOT {
   static TClass *vectorlESummary_FramegR_Dictionary();
   static void vectorlESummary_FramegR_TClassManip(TClass*);
   static void *new_vectorlESummary_FramegR(void *p = 0);
   static void *newArray_vectorlESummary_FramegR(Long_t size, void *p);
   static void delete_vectorlESummary_FramegR(void *p);
   static void deleteArray_vectorlESummary_FramegR(void *p);
   static void destruct_vectorlESummary_FramegR(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const vector<Summary_Frame>*)
   {
      vector<Summary_Frame> *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(vector<Summary_Frame>));
      static ::ROOT::TGenericClassInfo 
         instance("vector<Summary_Frame>", -2, "vector", 210,
                  typeid(vector<Summary_Frame>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &vectorlESummary_FramegR_Dictionary, isa_proxy, 4,
                  sizeof(vector<Summary_Frame>) );
      instance.SetNew(&new_vectorlESummary_FramegR);
      instance.SetNewArray(&newArray_vectorlESummary_FramegR);
      instance.SetDelete(&delete_vectorlESummary_FramegR);
      instance.SetDeleteArray(&deleteArray_vectorlESummary_FramegR);
      instance.SetDestructor(&destruct_vectorlESummary_FramegR);
      instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::Pushback< vector<Summary_Frame> >()));

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

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

   static void vectorlESummary_FramegR_TClassManip(TClass* ){
   }

} // end of namespace ROOT

namespace ROOT {
   // Wrappers around operator new
   static void *new_vectorlESummary_FramegR(void *p) {
      return  p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) vector<Summary_Frame> : new vector<Summary_Frame>;
   }
   static void *newArray_vectorlESummary_FramegR(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) vector<Summary_Frame>[nElements] : new vector<Summary_Frame>[nElements];
   }
   // Wrapper around operator delete
   static void delete_vectorlESummary_FramegR(void *p) {
      delete ((vector<Summary_Frame>*)p);
   }
   static void deleteArray_vectorlESummary_FramegR(void *p) {
      delete [] ((vector<Summary_Frame>*)p);
   }
   static void destruct_vectorlESummary_FramegR(void *p) {
      typedef vector<Summary_Frame> current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class vector<Summary_Frame>

namespace ROOT {
   static TClass *vectorlEStatus_ItemgR_Dictionary();
   static void vectorlEStatus_ItemgR_TClassManip(TClass*);
   static void *new_vectorlEStatus_ItemgR(void *p = 0);
   static void *newArray_vectorlEStatus_ItemgR(Long_t size, void *p);
   static void delete_vectorlEStatus_ItemgR(void *p);
   static void deleteArray_vectorlEStatus_ItemgR(void *p);
   static void destruct_vectorlEStatus_ItemgR(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const vector<Status_Item>*)
   {
      vector<Status_Item> *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(vector<Status_Item>));
      static ::ROOT::TGenericClassInfo 
         instance("vector<Status_Item>", -2, "vector", 210,
                  typeid(vector<Status_Item>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &vectorlEStatus_ItemgR_Dictionary, isa_proxy, 4,
                  sizeof(vector<Status_Item>) );
      instance.SetNew(&new_vectorlEStatus_ItemgR);
      instance.SetNewArray(&newArray_vectorlEStatus_ItemgR);
      instance.SetDelete(&delete_vectorlEStatus_ItemgR);
      instance.SetDeleteArray(&deleteArray_vectorlEStatus_ItemgR);
      instance.SetDestructor(&destruct_vectorlEStatus_ItemgR);
      instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::Pushback< vector<Status_Item> >()));

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

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

   static void vectorlEStatus_ItemgR_TClassManip(TClass* ){
   }

} // end of namespace ROOT

namespace ROOT {
   // Wrappers around operator new
   static void *new_vectorlEStatus_ItemgR(void *p) {
      return  p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) vector<Status_Item> : new vector<Status_Item>;
   }
   static void *newArray_vectorlEStatus_ItemgR(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) vector<Status_Item>[nElements] : new vector<Status_Item>[nElements];
   }
   // Wrapper around operator delete
   static void delete_vectorlEStatus_ItemgR(void *p) {
      delete ((vector<Status_Item>*)p);
   }
   static void deleteArray_vectorlEStatus_ItemgR(void *p) {
      delete [] ((vector<Status_Item>*)p);
   }
   static void destruct_vectorlEStatus_ItemgR(void *p) {
      typedef vector<Status_Item> current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class vector<Status_Item>

namespace ROOT {
   static TClass *vectorlEStatus_FramegR_Dictionary();
   static void vectorlEStatus_FramegR_TClassManip(TClass*);
   static void *new_vectorlEStatus_FramegR(void *p = 0);
   static void *newArray_vectorlEStatus_FramegR(Long_t size, void *p);
   static void delete_vectorlEStatus_FramegR(void *p);
   static void deleteArray_vectorlEStatus_FramegR(void *p);
   static void destruct_vectorlEStatus_FramegR(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const vector<Status_Frame>*)
   {
      vector<Status_Frame> *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(vector<Status_Frame>));
      static ::ROOT::TGenericClassInfo 
         instance("vector<Status_Frame>", -2, "vector", 210,
                  typeid(vector<Status_Frame>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &vectorlEStatus_FramegR_Dictionary, isa_proxy, 4,
                  sizeof(vector<Status_Frame>) );
      instance.SetNew(&new_vectorlEStatus_FramegR);
      instance.SetNewArray(&newArray_vectorlEStatus_FramegR);
      instance.SetDelete(&delete_vectorlEStatus_FramegR);
      instance.SetDeleteArray(&deleteArray_vectorlEStatus_FramegR);
      instance.SetDestructor(&destruct_vectorlEStatus_FramegR);
      instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::Pushback< vector<Status_Frame> >()));

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

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

   static void vectorlEStatus_FramegR_TClassManip(TClass* ){
   }

} // end of namespace ROOT

namespace ROOT {
   // Wrappers around operator new
   static void *new_vectorlEStatus_FramegR(void *p) {
      return  p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) vector<Status_Frame> : new vector<Status_Frame>;
   }
   static void *newArray_vectorlEStatus_FramegR(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) vector<Status_Frame>[nElements] : new vector<Status_Frame>[nElements];
   }
   // Wrapper around operator delete
   static void delete_vectorlEStatus_FramegR(void *p) {
      delete ((vector<Status_Frame>*)p);
   }
   static void deleteArray_vectorlEStatus_FramegR(void *p) {
      delete [] ((vector<Status_Frame>*)p);
   }
   static void destruct_vectorlEStatus_FramegR(void *p) {
      typedef vector<Status_Frame> current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class vector<Status_Frame>

namespace ROOT {
   static TClass *vectorlESPE_ItemgR_Dictionary();
   static void vectorlESPE_ItemgR_TClassManip(TClass*);
   static void *new_vectorlESPE_ItemgR(void *p = 0);
   static void *newArray_vectorlESPE_ItemgR(Long_t size, void *p);
   static void delete_vectorlESPE_ItemgR(void *p);
   static void deleteArray_vectorlESPE_ItemgR(void *p);
   static void destruct_vectorlESPE_ItemgR(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const vector<SPE_Item>*)
   {
      vector<SPE_Item> *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(vector<SPE_Item>));
      static ::ROOT::TGenericClassInfo 
         instance("vector<SPE_Item>", -2, "vector", 210,
                  typeid(vector<SPE_Item>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &vectorlESPE_ItemgR_Dictionary, isa_proxy, 4,
                  sizeof(vector<SPE_Item>) );
      instance.SetNew(&new_vectorlESPE_ItemgR);
      instance.SetNewArray(&newArray_vectorlESPE_ItemgR);
      instance.SetDelete(&delete_vectorlESPE_ItemgR);
      instance.SetDeleteArray(&deleteArray_vectorlESPE_ItemgR);
      instance.SetDestructor(&destruct_vectorlESPE_ItemgR);
      instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::Pushback< vector<SPE_Item> >()));

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

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

   static void vectorlESPE_ItemgR_TClassManip(TClass* ){
   }

} // end of namespace ROOT

namespace ROOT {
   // Wrappers around operator new
   static void *new_vectorlESPE_ItemgR(void *p) {
      return  p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) vector<SPE_Item> : new vector<SPE_Item>;
   }
   static void *newArray_vectorlESPE_ItemgR(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) vector<SPE_Item>[nElements] : new vector<SPE_Item>[nElements];
   }
   // Wrapper around operator delete
   static void delete_vectorlESPE_ItemgR(void *p) {
      delete ((vector<SPE_Item>*)p);
   }
   static void deleteArray_vectorlESPE_ItemgR(void *p) {
      delete [] ((vector<SPE_Item>*)p);
   }
   static void destruct_vectorlESPE_ItemgR(void *p) {
      typedef vector<SPE_Item> current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class vector<SPE_Item>

namespace ROOT {
   static TClass *vectorlESPE_HitgR_Dictionary();
   static void vectorlESPE_HitgR_TClassManip(TClass*);
   static void *new_vectorlESPE_HitgR(void *p = 0);
   static void *newArray_vectorlESPE_HitgR(Long_t size, void *p);
   static void delete_vectorlESPE_HitgR(void *p);
   static void deleteArray_vectorlESPE_HitgR(void *p);
   static void destruct_vectorlESPE_HitgR(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const vector<SPE_Hit>*)
   {
      vector<SPE_Hit> *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(vector<SPE_Hit>));
      static ::ROOT::TGenericClassInfo 
         instance("vector<SPE_Hit>", -2, "vector", 210,
                  typeid(vector<SPE_Hit>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &vectorlESPE_HitgR_Dictionary, isa_proxy, 4,
                  sizeof(vector<SPE_Hit>) );
      instance.SetNew(&new_vectorlESPE_HitgR);
      instance.SetNewArray(&newArray_vectorlESPE_HitgR);
      instance.SetDelete(&delete_vectorlESPE_HitgR);
      instance.SetDeleteArray(&deleteArray_vectorlESPE_HitgR);
      instance.SetDestructor(&destruct_vectorlESPE_HitgR);
      instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::Pushback< vector<SPE_Hit> >()));

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

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

   static void vectorlESPE_HitgR_TClassManip(TClass* ){
   }

} // end of namespace ROOT

namespace ROOT {
   // Wrappers around operator new
   static void *new_vectorlESPE_HitgR(void *p) {
      return  p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) vector<SPE_Hit> : new vector<SPE_Hit>;
   }
   static void *newArray_vectorlESPE_HitgR(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) vector<SPE_Hit>[nElements] : new vector<SPE_Hit>[nElements];
   }
   // Wrapper around operator delete
   static void delete_vectorlESPE_HitgR(void *p) {
      delete ((vector<SPE_Hit>*)p);
   }
   static void deleteArray_vectorlESPE_HitgR(void *p) {
      delete [] ((vector<SPE_Hit>*)p);
   }
   static void destruct_vectorlESPE_HitgR(void *p) {
      typedef vector<SPE_Hit> current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class vector<SPE_Hit>

namespace ROOT {
   static TClass *vectorlESPE_FramegR_Dictionary();
   static void vectorlESPE_FramegR_TClassManip(TClass*);
   static void *new_vectorlESPE_FramegR(void *p = 0);
   static void *newArray_vectorlESPE_FramegR(Long_t size, void *p);
   static void delete_vectorlESPE_FramegR(void *p);
   static void deleteArray_vectorlESPE_FramegR(void *p);
   static void destruct_vectorlESPE_FramegR(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const vector<SPE_Frame>*)
   {
      vector<SPE_Frame> *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(vector<SPE_Frame>));
      static ::ROOT::TGenericClassInfo 
         instance("vector<SPE_Frame>", -2, "vector", 210,
                  typeid(vector<SPE_Frame>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &vectorlESPE_FramegR_Dictionary, isa_proxy, 4,
                  sizeof(vector<SPE_Frame>) );
      instance.SetNew(&new_vectorlESPE_FramegR);
      instance.SetNewArray(&newArray_vectorlESPE_FramegR);
      instance.SetDelete(&delete_vectorlESPE_FramegR);
      instance.SetDeleteArray(&deleteArray_vectorlESPE_FramegR);
      instance.SetDestructor(&destruct_vectorlESPE_FramegR);
      instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::Pushback< vector<SPE_Frame> >()));

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

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

   static void vectorlESPE_FramegR_TClassManip(TClass* ){
   }

} // end of namespace ROOT

namespace ROOT {
   // Wrappers around operator new
   static void *new_vectorlESPE_FramegR(void *p) {
      return  p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) vector<SPE_Frame> : new vector<SPE_Frame>;
   }
   static void *newArray_vectorlESPE_FramegR(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) vector<SPE_Frame>[nElements] : new vector<SPE_Frame>[nElements];
   }
   // Wrapper around operator delete
   static void delete_vectorlESPE_FramegR(void *p) {
      delete ((vector<SPE_Frame>*)p);
   }
   static void deleteArray_vectorlESPE_FramegR(void *p) {
      delete [] ((vector<SPE_Frame>*)p);
   }
   static void destruct_vectorlESPE_FramegR(void *p) {
      typedef vector<SPE_Frame> current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class vector<SPE_Frame>

namespace ROOT {
   static TClass *vectorlERTS_ItemgR_Dictionary();
   static void vectorlERTS_ItemgR_TClassManip(TClass*);
   static void *new_vectorlERTS_ItemgR(void *p = 0);
   static void *newArray_vectorlERTS_ItemgR(Long_t size, void *p);
   static void delete_vectorlERTS_ItemgR(void *p);
   static void deleteArray_vectorlERTS_ItemgR(void *p);
   static void destruct_vectorlERTS_ItemgR(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const vector<RTS_Item>*)
   {
      vector<RTS_Item> *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(vector<RTS_Item>));
      static ::ROOT::TGenericClassInfo 
         instance("vector<RTS_Item>", -2, "vector", 210,
                  typeid(vector<RTS_Item>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &vectorlERTS_ItemgR_Dictionary, isa_proxy, 4,
                  sizeof(vector<RTS_Item>) );
      instance.SetNew(&new_vectorlERTS_ItemgR);
      instance.SetNewArray(&newArray_vectorlERTS_ItemgR);
      instance.SetDelete(&delete_vectorlERTS_ItemgR);
      instance.SetDeleteArray(&deleteArray_vectorlERTS_ItemgR);
      instance.SetDestructor(&destruct_vectorlERTS_ItemgR);
      instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::Pushback< vector<RTS_Item> >()));

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

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

   static void vectorlERTS_ItemgR_TClassManip(TClass* ){
   }

} // end of namespace ROOT

namespace ROOT {
   // Wrappers around operator new
   static void *new_vectorlERTS_ItemgR(void *p) {
      return  p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) vector<RTS_Item> : new vector<RTS_Item>;
   }
   static void *newArray_vectorlERTS_ItemgR(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) vector<RTS_Item>[nElements] : new vector<RTS_Item>[nElements];
   }
   // Wrapper around operator delete
   static void delete_vectorlERTS_ItemgR(void *p) {
      delete ((vector<RTS_Item>*)p);
   }
   static void deleteArray_vectorlERTS_ItemgR(void *p) {
      delete [] ((vector<RTS_Item>*)p);
   }
   static void destruct_vectorlERTS_ItemgR(void *p) {
      typedef vector<RTS_Item> current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class vector<RTS_Item>

namespace ROOT {
   static TClass *vectorlERTS_FramegR_Dictionary();
   static void vectorlERTS_FramegR_TClassManip(TClass*);
   static void *new_vectorlERTS_FramegR(void *p = 0);
   static void *newArray_vectorlERTS_FramegR(Long_t size, void *p);
   static void delete_vectorlERTS_FramegR(void *p);
   static void deleteArray_vectorlERTS_FramegR(void *p);
   static void destruct_vectorlERTS_FramegR(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const vector<RTS_Frame>*)
   {
      vector<RTS_Frame> *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(vector<RTS_Frame>));
      static ::ROOT::TGenericClassInfo 
         instance("vector<RTS_Frame>", -2, "vector", 210,
                  typeid(vector<RTS_Frame>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &vectorlERTS_FramegR_Dictionary, isa_proxy, 4,
                  sizeof(vector<RTS_Frame>) );
      instance.SetNew(&new_vectorlERTS_FramegR);
      instance.SetNewArray(&newArray_vectorlERTS_FramegR);
      instance.SetDelete(&delete_vectorlERTS_FramegR);
      instance.SetDeleteArray(&deleteArray_vectorlERTS_FramegR);
      instance.SetDestructor(&destruct_vectorlERTS_FramegR);
      instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::Pushback< vector<RTS_Frame> >()));

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

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

   static void vectorlERTS_FramegR_TClassManip(TClass* ){
   }

} // end of namespace ROOT

namespace ROOT {
   // Wrappers around operator new
   static void *new_vectorlERTS_FramegR(void *p) {
      return  p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) vector<RTS_Frame> : new vector<RTS_Frame>;
   }
   static void *newArray_vectorlERTS_FramegR(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) vector<RTS_Frame>[nElements] : new vector<RTS_Frame>[nElements];
   }
   // Wrapper around operator delete
   static void delete_vectorlERTS_FramegR(void *p) {
      delete ((vector<RTS_Frame>*)p);
   }
   static void deleteArray_vectorlERTS_FramegR(void *p) {
      delete [] ((vector<RTS_Frame>*)p);
   }
   static void destruct_vectorlERTS_FramegR(void *p) {
      typedef vector<RTS_Frame> current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class vector<RTS_Frame>

namespace ROOT {
   static TClass *vectorlEExtendedSummary_FramegR_Dictionary();
   static void vectorlEExtendedSummary_FramegR_TClassManip(TClass*);
   static void *new_vectorlEExtendedSummary_FramegR(void *p = 0);
   static void *newArray_vectorlEExtendedSummary_FramegR(Long_t size, void *p);
   static void delete_vectorlEExtendedSummary_FramegR(void *p);
   static void deleteArray_vectorlEExtendedSummary_FramegR(void *p);
   static void destruct_vectorlEExtendedSummary_FramegR(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const vector<ExtendedSummary_Frame>*)
   {
      vector<ExtendedSummary_Frame> *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(vector<ExtendedSummary_Frame>));
      static ::ROOT::TGenericClassInfo 
         instance("vector<ExtendedSummary_Frame>", -2, "vector", 210,
                  typeid(vector<ExtendedSummary_Frame>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &vectorlEExtendedSummary_FramegR_Dictionary, isa_proxy, 4,
                  sizeof(vector<ExtendedSummary_Frame>) );
      instance.SetNew(&new_vectorlEExtendedSummary_FramegR);
      instance.SetNewArray(&newArray_vectorlEExtendedSummary_FramegR);
      instance.SetDelete(&delete_vectorlEExtendedSummary_FramegR);
      instance.SetDeleteArray(&deleteArray_vectorlEExtendedSummary_FramegR);
      instance.SetDestructor(&destruct_vectorlEExtendedSummary_FramegR);
      instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::Pushback< vector<ExtendedSummary_Frame> >()));

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

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

   static void vectorlEExtendedSummary_FramegR_TClassManip(TClass* ){
   }

} // end of namespace ROOT

namespace ROOT {
   // Wrappers around operator new
   static void *new_vectorlEExtendedSummary_FramegR(void *p) {
      return  p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) vector<ExtendedSummary_Frame> : new vector<ExtendedSummary_Frame>;
   }
   static void *newArray_vectorlEExtendedSummary_FramegR(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) vector<ExtendedSummary_Frame>[nElements] : new vector<ExtendedSummary_Frame>[nElements];
   }
   // Wrapper around operator delete
   static void delete_vectorlEExtendedSummary_FramegR(void *p) {
      delete ((vector<ExtendedSummary_Frame>*)p);
   }
   static void deleteArray_vectorlEExtendedSummary_FramegR(void *p) {
      delete [] ((vector<ExtendedSummary_Frame>*)p);
   }
   static void destruct_vectorlEExtendedSummary_FramegR(void *p) {
      typedef vector<ExtendedSummary_Frame> current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class vector<ExtendedSummary_Frame>

namespace ROOT {
   static TClass *vectorlEDWF_ItemgR_Dictionary();
   static void vectorlEDWF_ItemgR_TClassManip(TClass*);
   static void *new_vectorlEDWF_ItemgR(void *p = 0);
   static void *newArray_vectorlEDWF_ItemgR(Long_t size, void *p);
   static void delete_vectorlEDWF_ItemgR(void *p);
   static void deleteArray_vectorlEDWF_ItemgR(void *p);
   static void destruct_vectorlEDWF_ItemgR(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const vector<DWF_Item>*)
   {
      vector<DWF_Item> *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(vector<DWF_Item>));
      static ::ROOT::TGenericClassInfo 
         instance("vector<DWF_Item>", -2, "vector", 210,
                  typeid(vector<DWF_Item>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &vectorlEDWF_ItemgR_Dictionary, isa_proxy, 4,
                  sizeof(vector<DWF_Item>) );
      instance.SetNew(&new_vectorlEDWF_ItemgR);
      instance.SetNewArray(&newArray_vectorlEDWF_ItemgR);
      instance.SetDelete(&delete_vectorlEDWF_ItemgR);
      instance.SetDeleteArray(&deleteArray_vectorlEDWF_ItemgR);
      instance.SetDestructor(&destruct_vectorlEDWF_ItemgR);
      instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::Pushback< vector<DWF_Item> >()));

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

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

   static void vectorlEDWF_ItemgR_TClassManip(TClass* ){
   }

} // end of namespace ROOT

namespace ROOT {
   // Wrappers around operator new
   static void *new_vectorlEDWF_ItemgR(void *p) {
      return  p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) vector<DWF_Item> : new vector<DWF_Item>;
   }
   static void *newArray_vectorlEDWF_ItemgR(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) vector<DWF_Item>[nElements] : new vector<DWF_Item>[nElements];
   }
   // Wrapper around operator delete
   static void delete_vectorlEDWF_ItemgR(void *p) {
      delete ((vector<DWF_Item>*)p);
   }
   static void deleteArray_vectorlEDWF_ItemgR(void *p) {
      delete [] ((vector<DWF_Item>*)p);
   }
   static void destruct_vectorlEDWF_ItemgR(void *p) {
      typedef vector<DWF_Item> current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class vector<DWF_Item>

namespace ROOT {
   static TClass *vectorlEDWF_HitgR_Dictionary();
   static void vectorlEDWF_HitgR_TClassManip(TClass*);
   static void *new_vectorlEDWF_HitgR(void *p = 0);
   static void *newArray_vectorlEDWF_HitgR(Long_t size, void *p);
   static void delete_vectorlEDWF_HitgR(void *p);
   static void deleteArray_vectorlEDWF_HitgR(void *p);
   static void destruct_vectorlEDWF_HitgR(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const vector<DWF_Hit>*)
   {
      vector<DWF_Hit> *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(vector<DWF_Hit>));
      static ::ROOT::TGenericClassInfo 
         instance("vector<DWF_Hit>", -2, "vector", 210,
                  typeid(vector<DWF_Hit>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &vectorlEDWF_HitgR_Dictionary, isa_proxy, 4,
                  sizeof(vector<DWF_Hit>) );
      instance.SetNew(&new_vectorlEDWF_HitgR);
      instance.SetNewArray(&newArray_vectorlEDWF_HitgR);
      instance.SetDelete(&delete_vectorlEDWF_HitgR);
      instance.SetDeleteArray(&deleteArray_vectorlEDWF_HitgR);
      instance.SetDestructor(&destruct_vectorlEDWF_HitgR);
      instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::Pushback< vector<DWF_Hit> >()));

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

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

   static void vectorlEDWF_HitgR_TClassManip(TClass* ){
   }

} // end of namespace ROOT

namespace ROOT {
   // Wrappers around operator new
   static void *new_vectorlEDWF_HitgR(void *p) {
      return  p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) vector<DWF_Hit> : new vector<DWF_Hit>;
   }
   static void *newArray_vectorlEDWF_HitgR(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) vector<DWF_Hit>[nElements] : new vector<DWF_Hit>[nElements];
   }
   // Wrapper around operator delete
   static void delete_vectorlEDWF_HitgR(void *p) {
      delete ((vector<DWF_Hit>*)p);
   }
   static void deleteArray_vectorlEDWF_HitgR(void *p) {
      delete [] ((vector<DWF_Hit>*)p);
   }
   static void destruct_vectorlEDWF_HitgR(void *p) {
      typedef vector<DWF_Hit> current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class vector<DWF_Hit>

namespace ROOT {
   static TClass *vectorlEDWF_FramegR_Dictionary();
   static void vectorlEDWF_FramegR_TClassManip(TClass*);
   static void *new_vectorlEDWF_FramegR(void *p = 0);
   static void *newArray_vectorlEDWF_FramegR(Long_t size, void *p);
   static void delete_vectorlEDWF_FramegR(void *p);
   static void deleteArray_vectorlEDWF_FramegR(void *p);
   static void destruct_vectorlEDWF_FramegR(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const vector<DWF_Frame>*)
   {
      vector<DWF_Frame> *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(vector<DWF_Frame>));
      static ::ROOT::TGenericClassInfo 
         instance("vector<DWF_Frame>", -2, "vector", 210,
                  typeid(vector<DWF_Frame>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &vectorlEDWF_FramegR_Dictionary, isa_proxy, 4,
                  sizeof(vector<DWF_Frame>) );
      instance.SetNew(&new_vectorlEDWF_FramegR);
      instance.SetNewArray(&newArray_vectorlEDWF_FramegR);
      instance.SetDelete(&delete_vectorlEDWF_FramegR);
      instance.SetDeleteArray(&deleteArray_vectorlEDWF_FramegR);
      instance.SetDestructor(&destruct_vectorlEDWF_FramegR);
      instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::Pushback< vector<DWF_Frame> >()));

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

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

   static void vectorlEDWF_FramegR_TClassManip(TClass* ){
   }

} // end of namespace ROOT

namespace ROOT {
   // Wrappers around operator new
   static void *new_vectorlEDWF_FramegR(void *p) {
      return  p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) vector<DWF_Frame> : new vector<DWF_Frame>;
   }
   static void *newArray_vectorlEDWF_FramegR(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) vector<DWF_Frame>[nElements] : new vector<DWF_Frame>[nElements];
   }
   // Wrapper around operator delete
   static void delete_vectorlEDWF_FramegR(void *p) {
      delete ((vector<DWF_Frame>*)p);
   }
   static void deleteArray_vectorlEDWF_FramegR(void *p) {
      delete [] ((vector<DWF_Frame>*)p);
   }
   static void destruct_vectorlEDWF_FramegR(void *p) {
      typedef vector<DWF_Frame> current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class vector<DWF_Frame>

namespace ROOT {
   static TClass *vectorlECRM_ItemgR_Dictionary();
   static void vectorlECRM_ItemgR_TClassManip(TClass*);
   static void *new_vectorlECRM_ItemgR(void *p = 0);
   static void *newArray_vectorlECRM_ItemgR(Long_t size, void *p);
   static void delete_vectorlECRM_ItemgR(void *p);
   static void deleteArray_vectorlECRM_ItemgR(void *p);
   static void destruct_vectorlECRM_ItemgR(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const vector<CRM_Item>*)
   {
      vector<CRM_Item> *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(vector<CRM_Item>));
      static ::ROOT::TGenericClassInfo 
         instance("vector<CRM_Item>", -2, "vector", 210,
                  typeid(vector<CRM_Item>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &vectorlECRM_ItemgR_Dictionary, isa_proxy, 4,
                  sizeof(vector<CRM_Item>) );
      instance.SetNew(&new_vectorlECRM_ItemgR);
      instance.SetNewArray(&newArray_vectorlECRM_ItemgR);
      instance.SetDelete(&delete_vectorlECRM_ItemgR);
      instance.SetDeleteArray(&deleteArray_vectorlECRM_ItemgR);
      instance.SetDestructor(&destruct_vectorlECRM_ItemgR);
      instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::Pushback< vector<CRM_Item> >()));

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

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

   static void vectorlECRM_ItemgR_TClassManip(TClass* ){
   }

} // end of namespace ROOT

namespace ROOT {
   // Wrappers around operator new
   static void *new_vectorlECRM_ItemgR(void *p) {
      return  p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) vector<CRM_Item> : new vector<CRM_Item>;
   }
   static void *newArray_vectorlECRM_ItemgR(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) vector<CRM_Item>[nElements] : new vector<CRM_Item>[nElements];
   }
   // Wrapper around operator delete
   static void delete_vectorlECRM_ItemgR(void *p) {
      delete ((vector<CRM_Item>*)p);
   }
   static void deleteArray_vectorlECRM_ItemgR(void *p) {
      delete [] ((vector<CRM_Item>*)p);
   }
   static void destruct_vectorlECRM_ItemgR(void *p) {
      typedef vector<CRM_Item> current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class vector<CRM_Item>

namespace ROOT {
   static TClass *vectorlECRM_FramegR_Dictionary();
   static void vectorlECRM_FramegR_TClassManip(TClass*);
   static void *new_vectorlECRM_FramegR(void *p = 0);
   static void *newArray_vectorlECRM_FramegR(Long_t size, void *p);
   static void delete_vectorlECRM_FramegR(void *p);
   static void deleteArray_vectorlECRM_FramegR(void *p);
   static void destruct_vectorlECRM_FramegR(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const vector<CRM_Frame>*)
   {
      vector<CRM_Frame> *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(vector<CRM_Frame>));
      static ::ROOT::TGenericClassInfo 
         instance("vector<CRM_Frame>", -2, "vector", 210,
                  typeid(vector<CRM_Frame>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &vectorlECRM_FramegR_Dictionary, isa_proxy, 4,
                  sizeof(vector<CRM_Frame>) );
      instance.SetNew(&new_vectorlECRM_FramegR);
      instance.SetNewArray(&newArray_vectorlECRM_FramegR);
      instance.SetDelete(&delete_vectorlECRM_FramegR);
      instance.SetDeleteArray(&deleteArray_vectorlECRM_FramegR);
      instance.SetDestructor(&destruct_vectorlECRM_FramegR);
      instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::Pushback< vector<CRM_Frame> >()));

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

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

   static void vectorlECRM_FramegR_TClassManip(TClass* ){
   }

} // end of namespace ROOT

namespace ROOT {
   // Wrappers around operator new
   static void *new_vectorlECRM_FramegR(void *p) {
      return  p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) vector<CRM_Frame> : new vector<CRM_Frame>;
   }
   static void *newArray_vectorlECRM_FramegR(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) vector<CRM_Frame>[nElements] : new vector<CRM_Frame>[nElements];
   }
   // Wrapper around operator delete
   static void delete_vectorlECRM_FramegR(void *p) {
      delete ((vector<CRM_Frame>*)p);
   }
   static void deleteArray_vectorlECRM_FramegR(void *p) {
      delete [] ((vector<CRM_Frame>*)p);
   }
   static void destruct_vectorlECRM_FramegR(void *p) {
      typedef vector<CRM_Frame> current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class vector<CRM_Frame>

namespace ROOT {
   static TClass *vectorlEAWF_ItemgR_Dictionary();
   static void vectorlEAWF_ItemgR_TClassManip(TClass*);
   static void *new_vectorlEAWF_ItemgR(void *p = 0);
   static void *newArray_vectorlEAWF_ItemgR(Long_t size, void *p);
   static void delete_vectorlEAWF_ItemgR(void *p);
   static void deleteArray_vectorlEAWF_ItemgR(void *p);
   static void destruct_vectorlEAWF_ItemgR(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const vector<AWF_Item>*)
   {
      vector<AWF_Item> *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(vector<AWF_Item>));
      static ::ROOT::TGenericClassInfo 
         instance("vector<AWF_Item>", -2, "vector", 210,
                  typeid(vector<AWF_Item>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &vectorlEAWF_ItemgR_Dictionary, isa_proxy, 4,
                  sizeof(vector<AWF_Item>) );
      instance.SetNew(&new_vectorlEAWF_ItemgR);
      instance.SetNewArray(&newArray_vectorlEAWF_ItemgR);
      instance.SetDelete(&delete_vectorlEAWF_ItemgR);
      instance.SetDeleteArray(&deleteArray_vectorlEAWF_ItemgR);
      instance.SetDestructor(&destruct_vectorlEAWF_ItemgR);
      instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::Pushback< vector<AWF_Item> >()));

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

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

   static void vectorlEAWF_ItemgR_TClassManip(TClass* ){
   }

} // end of namespace ROOT

namespace ROOT {
   // Wrappers around operator new
   static void *new_vectorlEAWF_ItemgR(void *p) {
      return  p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) vector<AWF_Item> : new vector<AWF_Item>;
   }
   static void *newArray_vectorlEAWF_ItemgR(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) vector<AWF_Item>[nElements] : new vector<AWF_Item>[nElements];
   }
   // Wrapper around operator delete
   static void delete_vectorlEAWF_ItemgR(void *p) {
      delete ((vector<AWF_Item>*)p);
   }
   static void deleteArray_vectorlEAWF_ItemgR(void *p) {
      delete [] ((vector<AWF_Item>*)p);
   }
   static void destruct_vectorlEAWF_ItemgR(void *p) {
      typedef vector<AWF_Item> current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class vector<AWF_Item>

namespace ROOT {
   static TClass *vectorlEAWF_HitgR_Dictionary();
   static void vectorlEAWF_HitgR_TClassManip(TClass*);
   static void *new_vectorlEAWF_HitgR(void *p = 0);
   static void *newArray_vectorlEAWF_HitgR(Long_t size, void *p);
   static void delete_vectorlEAWF_HitgR(void *p);
   static void deleteArray_vectorlEAWF_HitgR(void *p);
   static void destruct_vectorlEAWF_HitgR(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const vector<AWF_Hit>*)
   {
      vector<AWF_Hit> *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(vector<AWF_Hit>));
      static ::ROOT::TGenericClassInfo 
         instance("vector<AWF_Hit>", -2, "vector", 210,
                  typeid(vector<AWF_Hit>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &vectorlEAWF_HitgR_Dictionary, isa_proxy, 4,
                  sizeof(vector<AWF_Hit>) );
      instance.SetNew(&new_vectorlEAWF_HitgR);
      instance.SetNewArray(&newArray_vectorlEAWF_HitgR);
      instance.SetDelete(&delete_vectorlEAWF_HitgR);
      instance.SetDeleteArray(&deleteArray_vectorlEAWF_HitgR);
      instance.SetDestructor(&destruct_vectorlEAWF_HitgR);
      instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::Pushback< vector<AWF_Hit> >()));

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

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

   static void vectorlEAWF_HitgR_TClassManip(TClass* ){
   }

} // end of namespace ROOT

namespace ROOT {
   // Wrappers around operator new
   static void *new_vectorlEAWF_HitgR(void *p) {
      return  p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) vector<AWF_Hit> : new vector<AWF_Hit>;
   }
   static void *newArray_vectorlEAWF_HitgR(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) vector<AWF_Hit>[nElements] : new vector<AWF_Hit>[nElements];
   }
   // Wrapper around operator delete
   static void delete_vectorlEAWF_HitgR(void *p) {
      delete ((vector<AWF_Hit>*)p);
   }
   static void deleteArray_vectorlEAWF_HitgR(void *p) {
      delete [] ((vector<AWF_Hit>*)p);
   }
   static void destruct_vectorlEAWF_HitgR(void *p) {
      typedef vector<AWF_Hit> current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class vector<AWF_Hit>

namespace ROOT {
   static TClass *vectorlEAWF_FramegR_Dictionary();
   static void vectorlEAWF_FramegR_TClassManip(TClass*);
   static void *new_vectorlEAWF_FramegR(void *p = 0);
   static void *newArray_vectorlEAWF_FramegR(Long_t size, void *p);
   static void delete_vectorlEAWF_FramegR(void *p);
   static void deleteArray_vectorlEAWF_FramegR(void *p);
   static void destruct_vectorlEAWF_FramegR(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const vector<AWF_Frame>*)
   {
      vector<AWF_Frame> *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(vector<AWF_Frame>));
      static ::ROOT::TGenericClassInfo 
         instance("vector<AWF_Frame>", -2, "vector", 210,
                  typeid(vector<AWF_Frame>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &vectorlEAWF_FramegR_Dictionary, isa_proxy, 4,
                  sizeof(vector<AWF_Frame>) );
      instance.SetNew(&new_vectorlEAWF_FramegR);
      instance.SetNewArray(&newArray_vectorlEAWF_FramegR);
      instance.SetDelete(&delete_vectorlEAWF_FramegR);
      instance.SetDeleteArray(&deleteArray_vectorlEAWF_FramegR);
      instance.SetDestructor(&destruct_vectorlEAWF_FramegR);
      instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::Pushback< vector<AWF_Frame> >()));

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

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

   static void vectorlEAWF_FramegR_TClassManip(TClass* ){
   }

} // end of namespace ROOT

namespace ROOT {
   // Wrappers around operator new
   static void *new_vectorlEAWF_FramegR(void *p) {
      return  p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) vector<AWF_Frame> : new vector<AWF_Frame>;
   }
   static void *newArray_vectorlEAWF_FramegR(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) vector<AWF_Frame>[nElements] : new vector<AWF_Frame>[nElements];
   }
   // Wrapper around operator delete
   static void delete_vectorlEAWF_FramegR(void *p) {
      delete ((vector<AWF_Frame>*)p);
   }
   static void deleteArray_vectorlEAWF_FramegR(void *p) {
      delete [] ((vector<AWF_Frame>*)p);
   }
   static void destruct_vectorlEAWF_FramegR(void *p) {
      typedef vector<AWF_Frame> current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class vector<AWF_Frame>

namespace {
  void TriggerDictionaryInitialization_AntaresDAQDictionary_Impl() {
    static const char* headers[] = {
"0",
0
    };
    static const char* includePaths[] = {
"/builds/common/jpp/software/",
"/builds/common/jpp/externals/",
"/usr/local/include/",
"/builds/common/jpp/externals/antares-dataformat/",
0
    };
    static const char* fwdDeclCode = R"DICTFWDDCLS(
#line 1 "AntaresDAQDictionary dictionary forward declarations' payload"
#pragma clang diagnostic ignored "-Wkeyword-compat"
#pragma clang diagnostic ignored "-Wignored-attributes"
#pragma clang diagnostic ignored "-Wreturn-type-c-linkage"
extern int __Cling_AutoLoading_Map;
class Status_Item;
namespace std{template <typename _Tp> class __attribute__((annotate("$clingAutoload$bits/allocator.h")))  __attribute__((annotate("$clingAutoload$string")))  allocator;
}
class RTS_Item;
class CRM_Item;
class SPE_Item;
class AWF_Item;
class DWF_Item;
class Status_Frame;
class RTS_Frame;
class CRM_Frame;
class SPE_Frame;
class AWF_Frame;
class DWF_Frame;
class Summary_Frame;
class ExtendedSummary_Frame;
class TriggeredSPE_Hit;
class SPE_Hit;
class AWF_Hit;
class DWF_Hit;
class ARS_Item;
class AWF_Sample;
class DWF_Sample;
class WF_Header;
template <class T> class WF_Item;

class DaqFramePreamble;
class __attribute__((annotate("$clingAutoload$antares-dataformat/EventPreamble.hh")))  EventPreamble;
template <class T> class Frame;

template <class T> class TimeSlice;

class Status_TimeSlice;
class RTS_TimeSlice;
class CRM_TimeSlice;
class SPE_TimeSlice;
class AWF_TimeSlice;
class DWF_TimeSlice;
class Summary_TimeSlice;
class ExtendedSummary_TimeSlice;
template <class T> class ARS_Hit;

class PhysicsEvent;
)DICTFWDDCLS";
    static const char* payloadCode = R"DICTPAYLOAD(
#line 1 "AntaresDAQDictionary dictionary payload"

#ifndef NAMESPACE
  #define NAMESPACE KM3NET
#endif

#define _BACKWARD_BACKWARD_WARNING_H
// Inline headers
#ifndef __ANTARESDAQ__ARS__
#define __ANTARESDAQ__ARS__

#include <ostream>
#include <iomanip>

#include <TROOT.h>
#include <TObject.h>

#include "antares-dataformat/DataTypes.hh"


/**
 * ARS timestamp LSB [ns]
 */
static const double    ARS_TIMESTAMP_NS  =  25.0;


/**
 * ARS item interface.
 */
class ARS_Item {
public:
  /**
   * Virtual destructor.
   */
  virtual ~ARS_Item() {}

  ClassDef(ARS_Item,2);
};


/**
 * ARS STATUS
 */
class Status_Item :
  public ARS_Item
{
public:
  /** ARS status */
  unsigned char status;

  /** ARS timestamp (24 bits) */
  unsigned int  timestamp;

  /** 
   * Default constructor.
   */
  Status_Item() :
    status(0),
    timestamp(0)
  {}

  /**
   * Print ASCII.
   *
   * \param out     output stream
   * \param object  Status item
   * \return        output stream
   */
  friend std::ostream& operator<<(std::ostream& out, const Status_Item& object)
  {
    using namespace std;
    
    return out << setw(2) << setfill('0') << hex << (int) object.status 
	       << setw(6) << setfill('0') << hex << object.timestamp 
	       << setfill(' ') << dec;
  }

  /** ROOT class definition */
  ClassDef(Status_Item, 2);
};


/**
 * ARS RTS
 */
class RTS_Item :
  public Status_Item
{
public:
  /** 
   * Default constructor.
   */
  RTS_Item() :
    Status_Item()
  {}

  /** ROOT class definition */
  ClassDef(RTS_Item, 2);
};


/**
 * ARS CRM
 */
class CRM_Item :
  public Status_Item
{
public:
  /** ARS Count Rate Monitor value */
  unsigned char crm;

  /** 
   * Default constructor.
   */
  CRM_Item() :
    Status_Item(),
    crm(0)
  {}

  /**
   * Print ASCII.
   *
   * \param out     output stream
   * \param object  CRM item
   * \return        output stream
   */
  friend std::ostream& operator<<(std::ostream& out, const CRM_Item& object)
  {
    using namespace std;
    
    out << static_cast<const Status_Item&>(object);
    out << setw(2) << hex << object.crm << dec;

    return out;
  }
    
  /** ROOT class definition */
  ClassDef(CRM_Item, 2);
};


/**
 * ARS SPE
 */
class SPE_Item :
  public Status_Item
{
public:
  /** ARS Analogue to Voltage Convertor */
  unsigned char avc;

  /** ARS Time to Voltage Convertor */
  unsigned char tvc;

  /** 
   * Default constructor.
   */
  SPE_Item() :
    Status_Item(),
    avc(0),
    tvc(0)
  {}

  /**
   * Print ASCII.
   *
   * \param out     output stream
   * \param object  SPE item
   * \return        output stream
   */
  friend std::ostream& operator<<(std::ostream& out, const SPE_Item& object)
  { 
    using namespace std;

    out << static_cast<const Status_Item&>(object);
    out << setw(2) << setfill('0') << hex << (int) object.avc 
	<< setw(2) << setfill('0') << hex << (int) object.tvc 
	<< setfill(' ') << dec;

    return out;
  }
    
  /** ROOT class definition */
  ClassDef(SPE_Item, 2);
};


/**
 * Anode waveform sample
 */
class AWF_Sample { 
public:
  /** TVC */
  unsigned char time;
  /** AVC */
  unsigned char anode;

  /**
   * Default constructor.
   */
  AWF_Sample() :
    time(0),
    anode(0)
  {}

  /**
   * Virtual destructor.
   */
  virtual ~AWF_Sample() {};

  /** ROOT class definition */
  ClassDef(AWF_Sample, 2);
};


/**
 * Dynode waveform sample
 */
class DWF_Sample :
  public AWF_Sample
{
public:
  /** AVC dynode 1 */
  unsigned char dynode1;
  /** AVC dynode 2 */
  unsigned char dynode2;

  /**
   * Default constructor.
   */
  DWF_Sample() :
    AWF_Sample(),
    dynode1(0),
    dynode2(0)
  {}

  /** ROOT class definition */
  ClassDef(DWF_Sample, 2);
};


/**
 * ARS WF header interface
 *
 * Note that the waveform header is padded to 4x4 Bytes
 * due to the minimal bus transfer size of 4 words.
 */
class WF_Header :
  public SPE_Item
{
public:
  /** Waveform address */
  unsigned char waveformAddress;

  /**
   * Default constructor.
   */
  WF_Header() :
    SPE_Item(),
    waveformAddress(0)
  {}

  /** ROOT class definition */
  ClassDef(WF_Header, 2);
};


/**
 * ARS waveform
 */
template<class T>
class WF_Item :
  public WF_Header
{
protected:
  /**
   * number of waveform samples
   */
  static const unsigned int NUMBER_OF_SAMPLES = 128;

  /** data */
  T data_[NUMBER_OF_SAMPLES];

public:

  typedef T*       iterator;          //!< iterator
  typedef const T* const_iterator;    //!< const iterator

  /** begin iterator of waveform data */
  iterator begin() { return data_; }

  /** end iterator of waveform data */
  iterator end()   { return data_ + NUMBER_OF_SAMPLES; }

  /** access to waveform data */
  const T& operator[](const int i) { return data_[i]; }

  /**
   * Default constructor.
   */
  WF_Item() :
    WF_Header()
  {}

  /** ROOT class definition */
  ClassDef(WF_Item, 2);
};

ClassDefT2(WF_Item,T);
ClassImpT(WF_Item,T);


/**
 * ARS Anode waveform
 */ 
class AWF_Item :
  public WF_Item<AWF_Sample>
{
public:
  /**
   * Default constructor.
   */
  AWF_Item() : WF_Item<AWF_Sample>() {}

  /** ROOT class definition */
  ClassDef(AWF_Item, 2);
};


/**
 * ARS Dynode waveform
 */ 
class DWF_Item :
  public WF_Item<DWF_Sample>
{
public:
  /**
   * Default constructor.
   */
  DWF_Item() :
    WF_Item<DWF_Sample>()
  {}

  /** ROOT class definition */
  ClassDef(DWF_Item, 2);
};


/**
 * Determine the TVC number.
 *
 * \param  timestamp   ARS time stamp
 * \param  tvc         ARS TVC value
 * \return             0/1
 */
inline int getTVC(const unsigned int  timestamp, 
		  const unsigned char tvc)
{
  switch (timestamp & 0x3) {

  case 0:
    if (tvc & 0x80)
      return 1;
    else
      return 0;
    break;

  case 1:
    return 0;
    break;

  case 2:
    if (tvc & 0x80)
      return 0;
    else
      return 1;
    break;

  case 3:
    return 1;
    break;
  }

  return 0;
} 


/**
 * equal operator for Status item
 *
 * \param  first       Status item
 * \param  second      Status item
 * \return             true if first equals second; else false
 */
inline bool operator==(const Status_Item& first, const Status_Item& second)
{
  return (first.timestamp == second.timestamp);
}


/**
 * not-equal operator for Status item
 *
 * \param  first       Status item
 * \param  second      Status item
 * \return             true if first not equals second; else false
 */
inline bool operator!=(const Status_Item& first, const Status_Item& second)
{
  return (first.timestamp != second.timestamp);
}


/**
 * comparator for Status item; earliest hit first
 *
 * \param  first       Status item
 * \param  second      Status item
 * \return             true if first earlier than second; else false
 */
inline bool operator<(const Status_Item& first, const Status_Item& second)
{
  return (first.timestamp < second.timestamp);
}


/**
 * equal operator for SPE item
 *
 * \param  first       SPE item
 * \param  second      SPE item
 * \return             true if first equals second; else false
 */
inline bool operator==(const SPE_Item& first, const SPE_Item& second)
{
  return (first.timestamp == second.timestamp &&
	  first.tvc       == second.tvc);
}


/**
 * not-equal operator for SPE item
 *
 * \param  first       SPE item
 * \param  second      SPE item
 * \return             true if first not equals second; else false
 */
inline bool operator!=(const SPE_Item& first, const SPE_Item& second)
{
  return (first.timestamp != second.timestamp ||
	  first.tvc       != second.tvc);
}


/**
 * comparator for SPE item; earliest hit first
 *
 * \param  first       SPE item
 * \param  second      SPE item
 * \return             true if first earlier than second; else false
 */
inline bool operator<(const SPE_Item& first, const SPE_Item& second)
{
  if (first.timestamp == second.timestamp) {
      
    const int firstTvcInUse  = getTVC(first.timestamp,  first.tvc);
    const int secondTvcInUse = getTVC(second.timestamp, second.tvc);
      
    if (firstTvcInUse == secondTvcInUse)
      return first.tvc < second.tvc;
    else
      return firstTvcInUse < secondTvcInUse; //!
      
  } else {
    return first.timestamp < second.timestamp;
  }
}


/**
 * comparator for SPE item; earliest hit first
 *
 * \param  first       SPE item
 * \param  second      timestamp
 * \return             true if first earlier than second; else false
 */
inline bool operator<(const SPE_Item& first, const unsigned int second)
{
  return first.timestamp < second;
}


/**
 * comparator for SPE item; earliest hit first
 *
 * \param  first       timestamp
 * \param  second      SPE item
 * \return             true if first earlier than second; else false
 */
inline bool operator<(const unsigned int first, const SPE_Item& second)
{
  return first < second.timestamp;
}

#endif
#ifndef __ANTARESDAQ__FRAMEPREAMBLE__
#define __ANTARESDAQ__FRAMEPREAMBLE__

/**
 *  @file	FramePreamble.hh
 *  @author	Joris van Rantwijk
 *  @date	Feb 2002
 *
 *  Class definition for Antares DAQ Data-Frame Preamble.
 */

#include <ostream>
#include <iomanip>

#include <TROOT.h>
#include <TObject.h>

#include "antares-dataformat/ulonglong.hh"

/**
 *  This object holds the information from the 'preamble' of a data frame.
 */
class DaqFramePreamble { 
public:
  
  /** Total length of the frame in 4-byte words. */
  unsigned int       frameSize;
  
  /** Data type code (DAQ_xxx) */
  unsigned short     dataType;
  
  /** Unique code representing the shore station for this frame */
  unsigned short     frameTarget;
  
  /** Frame 'time stamp' in units of 50ns (MSW) */
  unsigned int       frameTime1;
  /** Frame 'time stamp' in units of 50ns (LSW) */
  unsigned int       frameTime2;
  /** \return 64 bit frame time */
  ulonglong          frameTime()
  {
    return ulonglong(frameTime1,frameTime2);
  }

  /** Number of frames since start of the run */
  unsigned int       frameIndex;
  
  /** Status of frame Xon/Xoff */
  unsigned short     status;
  
  /** Number of items actually sent in this frame */
  unsigned short     nbItems;
  
  /** ID of originating LCM */
  unsigned short     LCM_ID;
  
  /** ID of originating ARS */
  unsigned short     ARS_ID;
  
  /** Run-number as given by the RunControl */
  unsigned int       runNumber;

  /**
   * get LCM idendifier
   * \return       LCM identifier
   */
  const unsigned short lcm_id() const { return LCM_ID; }

  /**
   * get ARS idendifier
   * \return       ARS identifier
   */
  const unsigned short ars_id() const { return ARS_ID; }

  /**
   * get data type
   * \return       data type
   */
  const unsigned short data_type() const { return dataType; }

  /**
   * get number of items
   * \return       number of items
   */
  const unsigned short numberOfItems() const { return nbItems; }

  /**
   *  Return a pointer to the frame data buffer.
   *  The returned value points to the start of the frame preamble.
   * \return pointer to data
   */
  virtual const unsigned char* getdata() const { return NULL; }

  /**
   *  Return the length of the frame data buffer.
   *  The returned value is in <b>bytes</b> (not words), and includes
   *  the frame preamble.
   * \return length of data
   */
  virtual const unsigned int getdatalen() const { return Length(); }

  /** Construct an empty preamble object. */
  DaqFramePreamble() { };
  
  /**
   * destructor
   */
  virtual ~DaqFramePreamble() {};

  /** Return length of an encoded frame preamble in bytes. */
  static const unsigned int Length() { return 32; }

  /**
   * Print ASCII.
   *
   * \param  out     output stream
   * \param  object  frame preamble
   * \return         output stream
   */
  friend std::ostream& operator<<(std::ostream& out, const DaqFramePreamble& object)
  {
    using namespace std;
    
    out << "frameSize   " << object.frameSize   << endl;
    out << "dataType    " << object.dataType    << endl;
    out << "frameTarget " << object.frameTarget << endl;
    out << "frameTime1  " << object.frameTime1  << endl;
    out << "frameTime2  " << object.frameTime2  << endl;
    out << "frameIndex  " << object.frameIndex  << endl;
    out << "status      " << object.status      << endl;
    out << "nbItems     " << object.nbItems     << endl;
    out << "LCM_ID      " << object.LCM_ID      << endl;
    out << "ARS_ID      " << object.ARS_ID      << endl;
    out << "runNumber   " << object.runNumber   << endl;

    return out;
  }       

  ClassDef(DaqFramePreamble, 2);
};        


/**
 * equal operator for DAQ frame preamble
 *
 * \param  first    DAQ frame preamble
 * \param  second   DAQ frame preamble
 * \return          true if first equals second; else false
 */
static inline const bool operator==(const DaqFramePreamble& first, const DaqFramePreamble& second)
{
  return (first.dataType   == second.dataType   &&
	  first.frameIndex == second.frameIndex &&
	  first.LCM_ID     == second.LCM_ID     &&
	  first.ARS_ID     == second.ARS_ID     &&
	  first.runNumber  == second.runNumber);
}

/**
 * not-equal operator for DAQ frame preamble
 *
 * \param  first    DAQ frame preamble
 * \param  second   DAQ frame preamble
 * \return          true if first not equals second; else false
 */
static inline const bool operator!=(const DaqFramePreamble& first, const DaqFramePreamble& second)
{
  return (first.dataType   != second.dataType   ||
	  first.frameIndex != second.frameIndex ||
	  first.LCM_ID     != second.LCM_ID     ||
	  first.ARS_ID     != second.ARS_ID     ||
	  first.runNumber  != second.runNumber);
}
          
#endif

/* End */
#ifndef __ANTARESDAQ__TIMESLICE__
#define __ANTARESDAQ__TIMESLICE__

#include <ostream>
#include <iomanip>
#include <vector>
#include <algorithm>

#include <TROOT.h>
#include <TObject.h>

#include "antares-dataformat/DataTypes.hh"
#include "antares-dataformat/Ars.hh"
#include "antares-dataformat/FramePreamble.hh"
#include "antares-dataformat/EventPreamble.hh"


/**
 * Summary of Frame
 */
class Summary_Frame {
protected:
  /** LCM identifier */
  unsigned short lcm_id_;
  /** ARS identifier */
  unsigned char  ars_id_;
  /** data type */
  unsigned char  data_type_;
  /** number of items */
  unsigned short numberOfItems_;

public:
  /**
   * item type definition
   */
  typedef void item_type;

  /**
   * get LCM idendifier
   * \return       LCM identifier
   */
  const unsigned short lcm_id() const { return lcm_id_; }

  /**
   * get ARS idendifier
   * \return       ARS identifier
   */
  const unsigned char ars_id() const { return ars_id_; }

  /**
   * get data type
   * \return       data type
   */
  const unsigned char data_type() const { return data_type_; }

  /**
   * get number of items
   * \return       number of items
   */
  const unsigned short numberOfItems() const { return numberOfItems_; }

  /**
   * Default constructor.
   */
  Summary_Frame() :
    lcm_id_(0),
    ars_id_(0),
    data_type_(0),
    numberOfItems_(0)
  {}

  /**
   * Virtual destructor.
   */
  virtual ~Summary_Frame() {}
  
  /**
   * equal operator.
   *
   * \param  object   summary frame
   * \return          true if equals object; else false
   */
  const bool operator==(const Summary_Frame& object)
  {
    return (lcm_id_    == object.lcm_id_   &&
	    ars_id_    == object.ars_id_   &&
	    data_type_ == object.data_type_);
  }
  
  /**
   * not-equal operator.
   *
   * \param  object   summary frame
   * \return          true if not equals object; else false
   */
  const bool operator!=(const Summary_Frame& object) const
  {
    return (lcm_id_    != object.lcm_id_   ||
	    ars_id_    != object.ars_id_   ||
	    data_type_ != object.data_type_);
  }

  /**
   * less than operator.
   *
   * \param  object   summary frame
   * \return          true if less than object; else false
   */
  const bool operator<(const Summary_Frame& object) const
  {
    if (lcm_id_ == object.lcm_id_)
      if (ars_id_ == object.ars_id_)
	return data_type_ < object.data_type_;
      else
	return ars_id_ < object.ars_id_;
    else
      return lcm_id_ < object.lcm_id_;
  }

  /**
   * Print ASCII.
   *
   * \param  out     output stream
   * \param  object  Summary frame
   * \return         output stream
   */
  friend std::ostream& operator<<(std::ostream& out, const Summary_Frame& object)
  {
    using namespace std;
    
    return out << setw(5) << (int) object.lcm_id_        << ' ' 
	       << setw(2) << (int) object.ars_id_        << ' ' 
	       << setw(2) << (int) object.data_type_     << ' ' 
	       << setw(5) << (int) object.numberOfItems_ << endl;
  }

  /**
   * operator +=
   *
   * \param  object   summar frame
   * \return          this summay frame
   */
  Summary_Frame& operator+=(const Summary_Frame& object)
  {
    if (*this == object) {
      numberOfItems_ += object.numberOfItems_;
    }
    
    return *this;
  }

  /** ROOT class definition */
  ClassDef(Summary_Frame, 2);
};


class ExtendedSummary_Frame :
  public Summary_Frame
{
protected:
  /** number of items original */
  unsigned short numberOfItemsOrg_;

public:
  /**
   * item type definition
   */
  typedef void item_type;

  /**
   * get number of items original
   * \return       number of items
   */
  const unsigned short numberOfItemsOrg() const { return numberOfItemsOrg_; }

  /**
   * Default constructor.
   */
  ExtendedSummary_Frame() :
    Summary_Frame(),
    numberOfItemsOrg_(0)
  {}

  /**
   * Print ASCII.
   *
   * \param  out     output stream
   * \param  object  Extended Summary frame
   * \return         output stream
   */
  friend std::ostream& operator<<(std::ostream& out, const ExtendedSummary_Frame& object)
  {
    using namespace std;
    
    return out << setw(5) << (int) object.lcm_id_           << ' ' 
	       << setw(2) << (int) object.ars_id_           << ' ' 
	       << setw(2) << (int) object.data_type_        << ' ' 
	       << setw(5) << (int) object.numberOfItems_    << ' '
	       << setw(5) << (int) object.numberOfItemsOrg_ << endl;
  }

  /**
   * operator +=
   *
   * \param  object   extended summary frame
   * \return          this extended summary frame
   */
  ExtendedSummary_Frame& operator+=(const ExtendedSummary_Frame& object)
  {
    if (*this == object) {
      numberOfItems_    += object.numberOfItems_;
      numberOfItemsOrg_ += object.numberOfItemsOrg_;
    }
    return *this;
  }

  /** ROOT class definition */
  ClassDef(ExtendedSummary_Frame, 2);
};


/**
 * Template Frame for ARS data
 */
template<class T> class Frame :
  public DaqFramePreamble,
  public std::vector<T>
{
public:
  /**
   * item type definition
   */
  typedef T item_type;

  /**
   * Default constructor.
   */
  Frame() :
    DaqFramePreamble()
  {}

  /**
   * Print ASCII.
   *
   * \param  out     output stream
   * \param  object  frame
   * \return         output stream
   */
  friend std::ostream& operator<<(std::ostream& out, const Frame& object)
  {
    using namespace std;
    
    out << static_cast<const DaqFramePreamble&>(object);

    if (!object.empty()) {            
      out << ' ' << *(object. begin());
      out << " ... ";
      out << ' ' << *(object.rbegin());
      out << endl;
    }


    return out;
  }

  /**
   * operator +=
   *
   * \param  object   frame
   * \return          this frame
   */
  Frame<T>& operator+=(const Frame<T>& object)
  {
    if ((DaqFramePreamble&) *this == (DaqFramePreamble&) object) {
      for (typename Frame<T>::const_iterator i = object.begin(); i != object.end(); ++i) {
	this->insert(std::lower_bound(Frame<T>::begin(),Frame<T>::end(),*i),*i);
      }
    }
    
    return *this;
  }
		 
  /** ROOT class definition */
  ClassDef(Frame, 2);
};

ClassDefT2(Frame,T);
ClassImpT(Frame,T);


/**
 * Status frame
 */
class Status_Frame :
  public Frame<Status_Item>
{
public:
  /**
   * Default constructor.
   */
  Status_Frame() : Frame<Status_Item>() {}

  /** ROOT class definition */
  ClassDef(Status_Frame, 2);
};


/**
 * RTS frame
 */
class RTS_Frame :
  public Frame<RTS_Item>
{
public:
  /**
   * Default constructor.
   */
  RTS_Frame() : Frame<RTS_Item>() {}

  /** ROOT class definition */
  ClassDef(RTS_Frame, 2);
};


/**
 * CRM frame
 */
class CRM_Frame :
  public Frame<CRM_Item>
{
public:
  /**
   * Default constructor.
   */
  CRM_Frame() : Frame<CRM_Item>() {}

  /** ROOT class definition */
  ClassDef(CRM_Frame, 2);
};


/**
 * SPE frame
 */
class SPE_Frame :
  public Frame<SPE_Item>
{
public:
  /**
   * Default constructor.
   */
  SPE_Frame() : Frame<SPE_Item>() {}

  /** ROOT class definition */
  ClassDef(SPE_Frame, 2);
};


/**
 * AWF frame
 */
class AWF_Frame :
  public Frame<AWF_Item>
{
public:
  /**
   * Default constructor.
   */
  AWF_Frame() : Frame<AWF_Item>() {}

  /** ROOT class definition */
  ClassDef(AWF_Frame, 2);
};


/**
 * DWF frame
 */
class DWF_Frame :
  public Frame<DWF_Item>
{
public:
  /**
   * Default constructor.
   */
  DWF_Frame() : Frame<DWF_Item>() {}

  /** ROOT class definition */
  ClassDef(DWF_Frame, 2);
};

/**
 * Template TimeSlice 
 */ 
template<class T>
class TimeSlice :
  public EventPreamble,
  public std::vector<T>
{
public:
  typedef T frame_type;                              //!< item type definition 
  typedef typename frame_type::item_type item_type;  //!< item sub-type definition 

  /**
   * Default constructor.
   */
  TimeSlice() :
    EventPreamble(),
    std::vector<T>()
  {}

  /**
   * Constructor.
   *
   * \param  header  event preamble
   */
  TimeSlice(const EventPreamble& header) :
    EventPreamble(header),
    std::vector<T>()
  {}

  /**
   * Print ASCII.
   *
   * \param  out     output stream
   * \param  object  time slice
   * \return         output stream
   */
  friend std::ostream& operator<<(std::ostream& out, const TimeSlice<T>& object)
  {
    out << static_cast<const EventPreamble&>(object);
    
    for (typename TimeSlice<T>::const_iterator i = object.begin(); i != object.end(); ++i) {
      out << *i;
    }

    return out;
  }

  /**
   * operator +=
   *
   * \param  object   time slice
   * \return          this time slice
   */
  TimeSlice<T>& operator+=(const TimeSlice<T>& object)
  {
    if ((EventPreamble&) *this == (EventPreamble&) object) {

      typename TimeSlice<T>::const_iterator from;
      typename TimeSlice<T>::iterator       to;

      for (from = object.begin(); from != object.end(); ++from) {

	for (to = std::vector<T>::begin(); to != std::vector<T>::end(); ++to) {
	  if (*to == *from) {
	    *to += *from;
	    break;
	  }
	}
	
	if (to == std::vector<T>::end()) {
	  this->push_back(*from);
	}
      }
    }
    
    return *this;
  }

  /** ROOT class definition */
  ClassDef(TimeSlice, 2);
};

ClassDefT2(std::vector,T);
ClassImpT(std::vector,T);

ClassDefT2(TimeSlice,T);
ClassImpT(TimeSlice,T);


/**
 * Status time slices
 */
class Status_TimeSlice :
  public TimeSlice<Status_Frame>
{
public:
  /**
   * Default constructor.
   */
  Status_TimeSlice() : TimeSlice<Status_Frame>() {}

  /** ROOT class definition */
  ClassDef(Status_TimeSlice, 2);
};


/**
 * RTS time slices
 */
class RTS_TimeSlice :
  public TimeSlice<RTS_Frame>
{
public:
  /**
   * Default constructor.
   */
  RTS_TimeSlice() : TimeSlice<RTS_Frame>() {}

  /** ROOT class definition */
  ClassDef(RTS_TimeSlice, 2);
};


/**
 * CRM time slices
 */
class CRM_TimeSlice :
  public TimeSlice<CRM_Frame>
{
public:
  /**
   * Default constructor.
   */
  CRM_TimeSlice() : TimeSlice<CRM_Frame>() {}

  /** ROOT class definition */
  ClassDef(CRM_TimeSlice, 2);
};


/**
 * SPE time slices
 */
class SPE_TimeSlice :
  public TimeSlice<SPE_Frame>
{
public:
  /**
   * Default constructor.
   */
  SPE_TimeSlice() : TimeSlice<SPE_Frame>() {}

  /** ROOT class definition */
  ClassDef(SPE_TimeSlice, 2);
};


/**
 * AWF time slices
 */
class AWF_TimeSlice :
  public TimeSlice<AWF_Frame>
{
public:
  /**
   * Default constructor.
   */
  AWF_TimeSlice() : TimeSlice<AWF_Frame>() {}

  /** ROOT class definition */
  ClassDef(AWF_TimeSlice, 2);
};


/**
 * DWF time slices
 */
class DWF_TimeSlice :
  public TimeSlice<DWF_Frame>
{
public:
  /**
   * Default constructor.
   */
  DWF_TimeSlice() : TimeSlice<DWF_Frame>() {}

  /** ROOT class definition */
  ClassDef(DWF_TimeSlice, 2);
};


/**
 * Summary time slices
 */
class Summary_TimeSlice :
  public TimeSlice<Summary_Frame>
{
public:
  /**
   * Default constructor.
   */
  Summary_TimeSlice() : TimeSlice<Summary_Frame>() {}

  /**
   * Constructor.
   *
   * param  object   time slice
   */
  template<class T>
  Summary_TimeSlice(const TimeSlice<T>& object) : 
    TimeSlice<Summary_Frame>((const EventPreamble&) object)
  {
    for (typename TimeSlice<T>::const_iterator i = object.begin(); i != object.end(); ++i) {
      this->push_back(Summary_Frame(i->LCM_ID,
				    i->ARS_ID,
				    i->dataType,
				    i->nbItems));
    }
  }
  
  /**
   * operator +=
   *
   * \param  object   time slice
   * \return          this summary time slice
   */
  template<class T>
  Summary_TimeSlice& operator+=(const TimeSlice<T>& object)
  {
    if ((EventPreamble&) *this == (EventPreamble&) object) {
      for (typename TimeSlice<T>::const_iterator i = object.begin(); i != object.end(); ++i) {
	this->push_back(Summary_Frame(i->LCM_ID,
				      i->ARS_ID,
				      i->dataType,
				      i->nbItems));
      }
    }
    
    return *this;
  }

  /** ROOT class definition */
  ClassDef(Summary_TimeSlice, 2);
};
 

/**
 * ExtendedSummary time slices
 */
class ExtendedSummary_TimeSlice :
  public TimeSlice<ExtendedSummary_Frame>
{
public:
  /**
   * Default constructor.
   */
  ExtendedSummary_TimeSlice() : TimeSlice<ExtendedSummary_Frame>() {}

  /**
   * Constructor.
   *
   * param  object   time slice
   */
  template<class T>
  ExtendedSummary_TimeSlice(const TimeSlice<T>& object) : 
    TimeSlice<ExtendedSummary_Frame>((EventPreamble&) object)
  {
    for (typename TimeSlice<T>::const_iterator i = object.begin(); i != object.end(); ++i) {
      this->push_back(ExtendedSummary_Frame(i->LCM_ID,
					    i->ARS_ID,
					    i->dataType,
					    i->nbItems,
					    0));
    }
  }

  /** ROOT class definition */
  ClassDef(ExtendedSummary_TimeSlice, 2);
};

 
/**
 * equal operator for summary frame and DAQ frame preamble
 *
 * \param  first      summary frame
 * \param  second     DAQ frame preamble
 * \return            true if first equals second; else false
 */
inline const bool operator==(const Summary_Frame& first, const DaqFramePreamble& second)
{
  return (first.data_type() == second.dataType &&
          first.lcm_id()    == second.LCM_ID   &&
          first.ars_id()    == second.ARS_ID);
}

/**
 * equal operator for DAQ frame preamble and summary frame
 *
 * \param  first      DAQ frame preamble
 * \param  second     summary frame
 * \return            true if first equals second; else false
 */
inline const bool operator==(const DaqFramePreamble& first, const Summary_Frame& second)
{
  return (first.dataType == second.data_type() &&
          first.LCM_ID   == second.lcm_id()    &&
          first.ARS_ID   == second.ars_id());
}
 
/**
 * not-equal operator for summary frame and DAQ frame preamble
 *
 * \param  first      summary frame
 * \param  second     DAQ frame preamble
 * \return            true if first not equals second; else false
 */
inline const bool operator!=(const Summary_Frame& first, const DaqFramePreamble& second)
{
  return (first.data_type() != second.dataType ||
          first.lcm_id()    != second.LCM_ID   ||
          first.ars_id()    != second.ARS_ID);
}

/**
 * not-equal operator for DAQ frame preamble and summary frame
 *
 * \param  first      DAQ frame preamble
 * \param  second     summary frame
 * \return            true if first not equals second; else false
 */
inline const bool operator!=(const DaqFramePreamble& first, const Summary_Frame& second)
{
  return (first.dataType != second.data_type() ||
          first.LCM_ID   != second.lcm_id()    ||
          first.ARS_ID   != second.ars_id());
}

#endif

#ifndef __ANTARESDAQ_PHYSICSEVENT__
#define __ANTARESDAQ_PHYSICSEVENT__

#include <ostream>
#include <iomanip>
#include <vector>
#include <limits>

#include <TROOT.h>
#include <TObject.h>

#include "antares-dataformat/DataTypes.hh"
#include "antares-dataformat/Ars.hh"
#include "antares-dataformat/EventPreamble.hh"


/**
 * Template hit.
 */
template<class T>
class ARS_Hit : public T {
public:
  typedef T data_type;

  /** LCM identifier */
  unsigned short lcm_id;
  /** ARS identifier */
  unsigned char  ars_id;

  /**
   * Default constructor.
   */
  ARS_Hit() :
    T(),
    lcm_id(0),
    ars_id(0)
  {}

  /**
   * print ASCII
   * \param out     output stream
   * \param object  hit
   * \return        output stream
   */
  friend std::ostream& operator<<(std::ostream& out, const ARS_Hit& object)
  {
    using namespace std;
    
    out << setw(5) << (int) object. lcm_id << ' ' 
	<< setw(2) << (int) object. ars_id << ' ';
    out << static_cast<const T&>(object);

    return out;
  }

  ClassDef(ARS_Hit, 2);
};

ClassDefT2(ARS_Hit,T);
ClassImpT(ARS_Hit,T);


/**
 * SPE hit
 */
class SPE_Hit : public ARS_Hit<SPE_Item> {
public:
  /** 
   * Default constructor.
   */
  SPE_Hit() :
    ARS_Hit<SPE_Item>() 
  {}

  ClassDef(SPE_Hit, 2);
};


/**
 * AWF hit
 */
class AWF_Hit : public ARS_Hit<AWF_Item> {
public:
  /** 
   * Default constructor.
   */
  AWF_Hit() :
    ARS_Hit<AWF_Item>() 
  {}

  ClassDef(AWF_Hit, 2);
};


/**
 * DWF hit
 */
class DWF_Hit : public ARS_Hit<DWF_Item> {
public:
  /** 
   * Default constructor.
   */
  DWF_Hit() :
    ARS_Hit<DWF_Item>() 
  {}

  ClassDef(DWF_Hit, 2);
};


/**
 * Triggered SPE hit
 */
class TriggeredSPE_Hit : public SPE_Hit {
public:
  /** 
   * Default constructor.
   */
  TriggeredSPE_Hit() :
    SPE_Hit() 
  {}

  ClassDef(TriggeredSPE_Hit, 2);
};


/**
 * Physics event
 */
class PhysicsEvent :
  public EventPreamble
{
protected:
  unsigned int EventType_;
  unsigned int TriggerCounter_;
  double       MinT_;
  double       MaxT_;
  float        MaxA_;
  float        TotA_;
    
  std::vector<TriggeredSPE_Hit> TriggeredSPEHits_;
  std::vector<SPE_Hit>          SPEHits_;
  std::vector<AWF_Hit>          AWFHits_;
  std::vector<DWF_Hit>          DWFHits_;

public:
  /**
   * Default constructor.
   */
  PhysicsEvent() :
    EventPreamble(),
    EventType_(0),
    TriggerCounter_(0),
    MinT_(+std::numeric_limits<double>::max()),
    MaxT_(-std::numeric_limits<double>::max()),
    MaxA_(0),
    TotA_(0)
  {}

  /**
   * Virtual destructor.
   */
  virtual ~PhysicsEvent()
  {}
  
  /** Identifier of processor that created this event */
  const unsigned short FrameTarget()    const { return frameTarget; }
  /** most significant word of frametime */
  const unsigned int   FrameTime1()     const { return frameTime1; }
  /** least significant word of frametime */
  const unsigned int   FrameTime2()     const { return frameTime2; }
  /** frame index */
  const unsigned int   FrameIndex()     const { return frameIndex; }
  /** Run number */
  const unsigned int   RunNumber()      const { return runNumber; }

  /** Type of PhysicsEvent */
  const unsigned int   EventType()      const { return EventType_; }
  /** Trigger nr. since start of run */
  const unsigned int   TriggerCounter() const { return TriggerCounter_; }
  /** time of first hit in event */
  const double         MinT()           const { return MinT_; }
  /** time of last hit in event */
  const double         MaxT()           const { return MaxT_; }
  /** amplitude of largest hit in event */
  const float          MaxA()           const { return MaxA_; }
  /** sum of all amplitudes */
  const float          TotA()           const { return TotA_; }

  /** Triggered hits */
  const std::vector<TriggeredSPE_Hit>& TriggeredSPEHits() const { return TriggeredSPEHits_; }
  /** SPE hits */
  const std::vector<SPE_Hit>& SPE_Hits()                  const { return SPEHits_; }
  /** Waveform hits */
  const std::vector<AWF_Hit>& AWF_Hits()                  const { return AWFHits_; }
  /** Dynode hits */
  const std::vector<DWF_Hit>& DWF_Hits()                  const { return DWFHits_; }

  /**
   * Template vector<T>::iterator
   */
  template<class T> class const_iterator : public std::vector<T>::const_iterator {
  public:
    const_iterator() :
      std::vector<T>::const_iterator()
    {}
    
    const_iterator(const typename std::vector<T>::const_iterator& i) :
      std::vector<T>::const_iterator(i)
    {}

    const_iterator& operator=(const typename std::vector<T>::const_iterator& i)
    {
      (typename std::vector<T>::const_iterator&) *this = i;
      return *this;
    }
  };
  
  /** template size method for nested vector */
  template<class T> size_t size() const;

  /** template begin const_iterator for nested vector */
  template<class T> typename std::vector<T>::const_iterator begin() const;
  
  /** template end const_iterator for nested vector */
  template<class T> typename std::vector<T>::const_iterator end()   const;

  /**
   * Print ASCII.
   *
   * \param out     output stream
   * \param object  physics event
   * \return        output stream
   */
  friend std::ostream& operator<<(std::ostream& out, const PhysicsEvent& object)
  {
    using namespace std;
    
    out << " +-------------------------------------+ "               << endl;
    out << " |  EventType_      " << object.EventType_               << endl;
    out << " |  RunNumber_      " << object.RunNumber()              << endl;
    out << " |  TriggerCounter_ " << object.TriggerCounter_          << endl;
    out << " |  FrameTarget_    " << object.FrameTarget()            << endl;
    out << " |  FrameTime1_     " << object.FrameTime1()             << endl;
    out << " |  FrameTime2_     " << object.FrameTime2()             << endl;
    out << " |  FrameIndex_     " << object.FrameIndex()             << endl;
    out << setprecision(11) << setw(14) 
	<< " |  MinT_           " << object.MinT_                    << endl;
    out << setprecision(11) << setw(14) 
	<< " |  MaxT_           " << object.MaxT_                    << endl;
    out << setprecision( 6) << setw(10) 
	<< " |  MaxA_           " << object.MaxA_                    << endl;
    out << setprecision( 6) << setw(10) 
	<< " |  TotA_           " << object.TotA_                    << endl;
    out << " +-------------------------------------+ "               << endl;
    out << " | Triggered hits   " << object.TriggeredSPEHits_.size() << endl;
    out << " | SPE hits         " << object.SPEHits_.size()          << endl;
    out << " | AWF hits         " << object.AWFHits_.size()          << endl;
    out << " | DWF hits         " << object.DWFHits_.size()          << endl;
    out << " +-------------------------------------+ "               << endl;
    out << endl;

    return out;
  }

  ClassDef(PhysicsEvent, 2);
};


/** specialisation for TriggeredSPE_Hit size */
template<> inline size_t
PhysicsEvent::size<TriggeredSPE_Hit>() const
{
  return TriggeredSPEHits_.size();
}

/** specialisation for SPE_Hit size */
template<> inline size_t
PhysicsEvent::size<SPE_Hit>() const
{
  return SPEHits_.size();
}

/** specialisation for AWF_Hit size */
template<> inline size_t
PhysicsEvent::size<AWF_Hit>() const
{
  return AWFHits_.size();
}

/** specialisation for DWF_Hit size */
template<> inline size_t
PhysicsEvent::size<DWF_Hit>() const
{
  return DWFHits_.size();
}

/** specialisation for TriggeredSPE_Hit iterator begin */
template<> inline std::vector<TriggeredSPE_Hit>::const_iterator
PhysicsEvent::begin<TriggeredSPE_Hit>() const
{
  return TriggeredSPEHits_.begin();
}

/** specialisation for TriggeredSPE_Hit iterator end */
template<> inline std::vector<TriggeredSPE_Hit>::const_iterator
PhysicsEvent::end<TriggeredSPE_Hit>() const
{
  return TriggeredSPEHits_.end();
}

/** specialisation for SPE_Hit iterator begin */
template<> inline std::vector<SPE_Hit>::const_iterator
PhysicsEvent::begin<SPE_Hit>() const
{
  return SPEHits_.begin();
}

/** specialisation for SPE_Hit iterator end */
template<> inline std::vector<SPE_Hit>::const_iterator
PhysicsEvent::end<SPE_Hit>() const
{
  return SPEHits_.end();
}

/** specialisation for AWF_Hit iterator begin */
template<> inline std::vector<AWF_Hit>::const_iterator
PhysicsEvent::begin<AWF_Hit>() const
{
  return AWFHits_.begin();
}

/** specialisation for AWF_Hit iterator end */
template<> inline std::vector<AWF_Hit>::const_iterator
PhysicsEvent::end<AWF_Hit>() const
{
  return AWFHits_.end();
}

/** specialisation for DWF_Hit iterator begin */
template<> inline std::vector<DWF_Hit>::const_iterator
PhysicsEvent::begin<DWF_Hit>() const
{
  return DWFHits_.begin();
}

/** specialisation for DWF_Hit iterator end */
template<> inline std::vector<DWF_Hit>::const_iterator
PhysicsEvent::end<DWF_Hit>() const
{
  return DWFHits_.end();
}


/**
 * equal operator for SPE hit.
 *
 * \param  first       SPE hit
 * \param  second      SPE hit
 * \return             true if first equals second; else false
 */
inline bool operator==(const SPE_Hit& first, const SPE_Hit& second)
{
  return (first.lcm_id    == second.lcm_id    &&
	  first.ars_id    == second.ars_id    &&
	  first.timestamp == second.timestamp &&
	  first.tvc       == second.tvc       &&
	  first.avc       == second.avc);
}

/**
 * not-equal operator for SPE hit.
 *
 * \param  first       SPE hit
 * \param  second      SPE hit
 * \return             true if first not equals second; else false
 */
inline bool operator!=(const SPE_Hit& first, const SPE_Hit& second)
{
  return (first.lcm_id    != second.lcm_id    ||
	  first.ars_id    != second.ars_id    ||
	  first.timestamp != second.timestamp ||
	  first.tvc       != second.tvc       ||
	  first.avc       != second.avc);
}


/**
 * equal operator for physics event.
 *
 * \param  first       physics event
 * \param  second      physics event
 * \return             true if first equals second; else false
 */
inline bool operator==(const PhysicsEvent& first, const PhysicsEvent& second)
{
  return (first.MinT() < second.MaxT() &&
	  first.MaxT() > second.MinT());
}

/**
 * not-equal operator for physics event.
 *
 * \param  first       physics event
 * \param  second      physics event
 * \return             true if first not equals second; else false
 */
inline bool operator!=(const PhysicsEvent& first, const PhysicsEvent& second)
{
  return (first.MinT() > second.MaxT() ||
	  first.MaxT() < second.MinT());
}

/**
 * Comparator for physics event; earliest event first.
 *
 * \param  first       physics event
 * \param  second      physics event
 * \return             true if first earlier than second; else false
 */
inline bool operator<(const PhysicsEvent& first, const PhysicsEvent& second)
{
  return first.MinT() < second.MinT();
}

/**
 * Specialisation of STL distance.
 *
 * \param  first       first position
 * \param  second      last  position
 * \return             distance
 */
template<class T>
inline typename std::vector<T>::difference_type distance(typename std::vector<T>::const_iterator  first,
							 typename PhysicsEvent::const_iterator<T> second)
{
  return std::distance(first, (typename std::vector<T>::const_iterator&) second);
}
 
#endif
#ifndef __ANTARESDAQ__EVENTPREAMBLE__
#define __ANTARESDAQ__EVENTPREAMBLE__

#include <ostream>
#include <iomanip>

#include <TROOT.h>
#include <TObject.h>

#include "antares-dataformat/FramePreamble.hh"
#include "antares-dataformat/DataTypes.hh"

/**
 * Interface for event classes.
 * It holds the information from the 'preamble' of an event object.
 */
class EventPreamble :
  public TObject
{
protected:
  //unsigned int       length_;          //!< size of object in bytes; not to be written by ROOT
  //unsigned short     dataType;         //!< type of object; not to be written by ROOT

public:
  /** Unique code representing the shore station for this frame */
  unsigned short     frameTarget;
  
  /** Frame 'time stamp' in units of 50ns (MSW) */
  unsigned int       frameTime1;
  /** Frame 'time stamp' in units of 50ns (LSW) */
  unsigned int       frameTime2;

  /** Number of frames since start of the run */
  unsigned int       frameIndex;

  /** Run-number as given by the RunControl */
  unsigned int       runNumber;

public:
  /** 
   * Default constructor.
   */
  EventPreamble()
  {
    //length_     = 0;
    //dataType    = UNDEFINED_EVENT_TYPE;
    frameTarget = 0;
    frameTime1  = 0;
    frameTime2  = 0;
    frameIndex  = 0;
    runNumber   = 0;
  }

  /**
   * Virtual destructor.
   */
  virtual ~EventPreamble() {};

  /**
   * Print ASCII.
   *
   * \param  out     output stream
   * \param  object  event preamble
   * \return         output stream
   */
  friend std::ostream& operator<<(std::ostream& out, const EventPreamble& object)
  {
    using namespace std;
    
    out << "frameTarget " << object.frameTarget << endl;
    out << "frameTime1  " << object.frameTime1  << endl;
    out << "frameTime2  " << object.frameTime2  << endl;
    out << "frameIndex  " << object.frameIndex  << endl;
    out << "runNumber   " << object.runNumber   << endl;

    return out;
  }

  ClassDef(EventPreamble, 2);
};


/**
 * equal operator for event preamble
 *
 * \param  first    event preamble
 * \param  second   event preamble
 * \return          true if first equals second; else false
 */
inline bool operator==(const EventPreamble& first, const EventPreamble& second)
{
  return (first.frameIndex == second.frameIndex &&
	  first.runNumber  == second.runNumber);
}

/**
 * not-equal operator for event preamble
 *
 * \param  first    event preamble
 * \param  second   event preamble
 * \return          true if first not equals second; else false
 */
inline bool operator!=(const EventPreamble& first, const EventPreamble& second)
{
  return (first.frameIndex != second.frameIndex ||
	  first.runNumber  != second.runNumber);
}

#endif


#undef  _BACKWARD_BACKWARD_WARNING_H
)DICTPAYLOAD";
    static const char* classesHeaders[] = {
"ARS_Hit<AWF_Item>", payloadCode, "@",
"ARS_Hit<DWF_Item>", payloadCode, "@",
"ARS_Hit<SPE_Item>", payloadCode, "@",
"ARS_Item", payloadCode, "@",
"AWF_Frame", payloadCode, "@",
"AWF_Hit", payloadCode, "@",
"AWF_Item", payloadCode, "@",
"AWF_Sample", payloadCode, "@",
"AWF_TimeSlice", payloadCode, "@",
"CRM_Frame", payloadCode, "@",
"CRM_Item", payloadCode, "@",
"CRM_TimeSlice", payloadCode, "@",
"DWF_Frame", payloadCode, "@",
"DWF_Hit", payloadCode, "@",
"DWF_Item", payloadCode, "@",
"DWF_Sample", payloadCode, "@",
"DWF_TimeSlice", payloadCode, "@",
"DaqFramePreamble", payloadCode, "@",
"EventPreamble", payloadCode, "@",
"ExtendedSummary_Frame", payloadCode, "@",
"ExtendedSummary_TimeSlice", payloadCode, "@",
"Frame<AWF_Item>", payloadCode, "@",
"Frame<CRM_Item>", payloadCode, "@",
"Frame<DWF_Item>", payloadCode, "@",
"Frame<RTS_Item>", payloadCode, "@",
"Frame<SPE_Item>", payloadCode, "@",
"Frame<Status_Item>", payloadCode, "@",
"PhysicsEvent", payloadCode, "@",
"RTS_Frame", payloadCode, "@",
"RTS_Item", payloadCode, "@",
"RTS_TimeSlice", payloadCode, "@",
"SPE_Frame", payloadCode, "@",
"SPE_Hit", payloadCode, "@",
"SPE_Item", payloadCode, "@",
"SPE_TimeSlice", payloadCode, "@",
"Status_Frame", payloadCode, "@",
"Status_Item", payloadCode, "@",
"Status_TimeSlice", payloadCode, "@",
"Summary_Frame", payloadCode, "@",
"Summary_TimeSlice", payloadCode, "@",
"TimeSlice<AWF_Frame>", payloadCode, "@",
"TimeSlice<CRM_Frame>", payloadCode, "@",
"TimeSlice<DWF_Frame>", payloadCode, "@",
"TimeSlice<ExtendedSummary_Frame>", payloadCode, "@",
"TimeSlice<RTS_Frame>", payloadCode, "@",
"TimeSlice<SPE_Frame>", payloadCode, "@",
"TimeSlice<Status_Frame>", payloadCode, "@",
"TimeSlice<Summary_Frame>", payloadCode, "@",
"TriggeredSPE_Hit", payloadCode, "@",
"WF_Header", payloadCode, "@",
"WF_Item<AWF_Sample>", payloadCode, "@",
"WF_Item<DWF_Sample>", payloadCode, "@",
nullptr
};
    static bool isInitialized = false;
    if (!isInitialized) {
      TROOT::RegisterModule("AntaresDAQDictionary",
        headers, includePaths, payloadCode, fwdDeclCode,
        TriggerDictionaryInitialization_AntaresDAQDictionary_Impl, {}, classesHeaders, /*hasCxxModule*/false);
      isInitialized = true;
    }
  }
  static struct DictInit {
    DictInit() {
      TriggerDictionaryInitialization_AntaresDAQDictionary_Impl();
    }
  } __TheDictionaryInitializer;
}
void TriggerDictionaryInitialization_AntaresDAQDictionary() {
  TriggerDictionaryInitialization_AntaresDAQDictionary_Impl();
}