L1RpcTriggerAnalysis/src/rootMAnaDict.cc

//
// File generated by /afs/cern.ch/cms/sw/slc5_ia32_gcc434/lcg/root/5.22.00d-cms18//bin/rootcint at Wed Jun 30 17:26:25 2010

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

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

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

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

#ifndef G__ROOT
#define G__ROOT
#endif

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

// START OF SHADOWS

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

namespace ROOT {
   void EventObj_ShowMembers(void *obj, TMemberInspector &R__insp, char *R__parent);
   static void *new_EventObj(void *p = 0);
   static void *newArray_EventObj(Long_t size, void *p);
   static void delete_EventObj(void *p);
   static void deleteArray_EventObj(void *p);
   static void destruct_EventObj(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::EventObj*)
   {
      ::EventObj *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::EventObj >(0);
      static ::ROOT::TGenericClassInfo 
         instance("EventObj", ::EventObj::Class_Version(), "../../../UserCode/L1RpcTriggerAnalysis/interface/EventObj.h", 5,
                  typeid(::EventObj), DefineBehavior(ptr, ptr),
                  &::EventObj::Dictionary, isa_proxy, 0,
                  sizeof(::EventObj) );
      instance.SetNew(&new_EventObj);
      instance.SetNewArray(&newArray_EventObj);
      instance.SetDelete(&delete_EventObj);
      instance.SetDeleteArray(&deleteArray_EventObj);
      instance.SetDestructor(&destruct_EventObj);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::EventObj*)
   {
      return GenerateInitInstanceLocal((::EventObj*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::EventObj*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TrackObj_ShowMembers(void *obj, TMemberInspector &R__insp, char *R__parent);
   static void *new_TrackObj(void *p = 0);
   static void *newArray_TrackObj(Long_t size, void *p);
   static void delete_TrackObj(void *p);
   static void deleteArray_TrackObj(void *p);
   static void destruct_TrackObj(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TrackObj*)
   {
      ::TrackObj *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TrackObj >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TrackObj", ::TrackObj::Class_Version(), "../../../UserCode/L1RpcTriggerAnalysis/interface/TrackObj.h", 5,
                  typeid(::TrackObj), DefineBehavior(ptr, ptr),
                  &::TrackObj::Dictionary, isa_proxy, 0,
                  sizeof(::TrackObj) );
      instance.SetNew(&new_TrackObj);
      instance.SetNewArray(&newArray_TrackObj);
      instance.SetDelete(&delete_TrackObj);
      instance.SetDeleteArray(&deleteArray_TrackObj);
      instance.SetDestructor(&destruct_TrackObj);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TrackObj*)
   {
      return GenerateInitInstanceLocal((::TrackObj*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TrackObj*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void MuonObj_ShowMembers(void *obj, TMemberInspector &R__insp, char *R__parent);
   static void *new_MuonObj(void *p = 0);
   static void *newArray_MuonObj(Long_t size, void *p);
   static void delete_MuonObj(void *p);
   static void deleteArray_MuonObj(void *p);
   static void destruct_MuonObj(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::MuonObj*)
   {
      ::MuonObj *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::MuonObj >(0);
      static ::ROOT::TGenericClassInfo 
         instance("MuonObj", ::MuonObj::Class_Version(), "../../../UserCode/L1RpcTriggerAnalysis/interface/MuonObj.h", 5,
                  typeid(::MuonObj), DefineBehavior(ptr, ptr),
                  &::MuonObj::Dictionary, isa_proxy, 0,
                  sizeof(::MuonObj) );
      instance.SetNew(&new_MuonObj);
      instance.SetNewArray(&newArray_MuonObj);
      instance.SetDelete(&delete_MuonObj);
      instance.SetDeleteArray(&deleteArray_MuonObj);
      instance.SetDestructor(&destruct_MuonObj);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::MuonObj*)
   {
      return GenerateInitInstanceLocal((::MuonObj*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::MuonObj*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void L1Obj_ShowMembers(void *obj, TMemberInspector &R__insp, char *R__parent);
   static void *new_L1Obj(void *p = 0);
   static void *newArray_L1Obj(Long_t size, void *p);
   static void delete_L1Obj(void *p);
   static void deleteArray_L1Obj(void *p);
   static void destruct_L1Obj(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::L1Obj*)
   {
      ::L1Obj *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::L1Obj >(0);
      static ::ROOT::TGenericClassInfo 
         instance("L1Obj", ::L1Obj::Class_Version(), "../../../UserCode/L1RpcTriggerAnalysis/interface/L1Obj.h", 5,
                  typeid(::L1Obj), DefineBehavior(ptr, ptr),
                  &::L1Obj::Dictionary, isa_proxy, 0,
                  sizeof(::L1Obj) );
      instance.SetNew(&new_L1Obj);
      instance.SetNewArray(&newArray_L1Obj);
      instance.SetDelete(&delete_L1Obj);
      instance.SetDeleteArray(&deleteArray_L1Obj);
      instance.SetDestructor(&destruct_L1Obj);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::L1Obj*)
   {
      return GenerateInitInstanceLocal((::L1Obj*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::L1Obj*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void L1ObjColl_ShowMembers(void *obj, TMemberInspector &R__insp, char *R__parent);
   static void *new_L1ObjColl(void *p = 0);
   static void *newArray_L1ObjColl(Long_t size, void *p);
   static void delete_L1ObjColl(void *p);
   static void deleteArray_L1ObjColl(void *p);
   static void destruct_L1ObjColl(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::L1ObjColl*)
   {
      ::L1ObjColl *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::L1ObjColl >(0);
      static ::ROOT::TGenericClassInfo 
         instance("L1ObjColl", ::L1ObjColl::Class_Version(), "../../../UserCode/L1RpcTriggerAnalysis/interface/L1ObjColl.h", 7,
                  typeid(::L1ObjColl), DefineBehavior(ptr, ptr),
                  &::L1ObjColl::Dictionary, isa_proxy, 0,
                  sizeof(::L1ObjColl) );
      instance.SetNew(&new_L1ObjColl);
      instance.SetNewArray(&newArray_L1ObjColl);
      instance.SetDelete(&delete_L1ObjColl);
      instance.SetDeleteArray(&deleteArray_L1ObjColl);
      instance.SetDestructor(&destruct_L1ObjColl);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::L1ObjColl*)
   {
      return GenerateInitInstanceLocal((::L1ObjColl*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::L1ObjColl*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

   UInt_t R__s, R__c;
   if (R__b.IsReading()) {
      Version_t R__v = R__b.ReadVersion(&R__s, &R__c); if (R__v) { }
      TObject::Streamer(R__b);
      R__b >> bx;
      R__b >> id;
      R__b >> lumi;
      R__b >> run;
      R__b >> time;
      R__b >> orbit;
      R__b.CheckByteCount(R__s, R__c, EventObj::IsA());
   } else {
      R__c = R__b.WriteVersion(EventObj::IsA(), kTRUE);
      TObject::Streamer(R__b);
      R__b << bx;
      R__b << id;
      R__b << lumi;
      R__b << run;
      R__b << time;
      R__b << orbit;
      R__b.SetByteCount(R__c, kTRUE);
   }
}

//______________________________________________________________________________
void EventObj::ShowMembers(TMemberInspector &R__insp, char *R__parent)
{
      // Inspect the data members of an object of class EventObj.
      TClass *R__cl = ::EventObj::IsA();
      Int_t R__ncp = strlen(R__parent);
      if (R__ncp || R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__parent, "bx", &bx);
      R__insp.Inspect(R__cl, R__parent, "id", &id);
      R__insp.Inspect(R__cl, R__parent, "lumi", &lumi);
      R__insp.Inspect(R__cl, R__parent, "run", &run);
      R__insp.Inspect(R__cl, R__parent, "time", &time);
      R__insp.Inspect(R__cl, R__parent, "orbit", &orbit);
      TObject::ShowMembers(R__insp, R__parent);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_EventObj(void *p) {
      return  p ? new(p) ::EventObj : new ::EventObj;
   }
   static void *newArray_EventObj(Long_t nElements, void *p) {
      return p ? new(p) ::EventObj[nElements] : new ::EventObj[nElements];
   }
   // Wrapper around operator delete
   static void delete_EventObj(void *p) {
      delete ((::EventObj*)p);
   }
   static void deleteArray_EventObj(void *p) {
      delete [] ((::EventObj*)p);
   }
   static void destruct_EventObj(void *p) {
      typedef ::EventObj current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::EventObj

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

   UInt_t R__s, R__c;
   if (R__b.IsReading()) {
      Version_t R__v = R__b.ReadVersion(&R__s, &R__c); if (R__v) { }
      TObject::Streamer(R__b);
      R__b >> thePt;
      R__b >> theEta;
      R__b >> thePhi;
      R__b >> theCharge;
      R__b.CheckByteCount(R__s, R__c, TrackObj::IsA());
   } else {
      R__c = R__b.WriteVersion(TrackObj::IsA(), kTRUE);
      TObject::Streamer(R__b);
      R__b << thePt;
      R__b << theEta;
      R__b << thePhi;
      R__b << theCharge;
      R__b.SetByteCount(R__c, kTRUE);
   }
}

//______________________________________________________________________________
void TrackObj::ShowMembers(TMemberInspector &R__insp, char *R__parent)
{
      // Inspect the data members of an object of class TrackObj.
      TClass *R__cl = ::TrackObj::IsA();
      Int_t R__ncp = strlen(R__parent);
      if (R__ncp || R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__parent, "thePt", &thePt);
      R__insp.Inspect(R__cl, R__parent, "theEta", &theEta);
      R__insp.Inspect(R__cl, R__parent, "thePhi", &thePhi);
      R__insp.Inspect(R__cl, R__parent, "theCharge", &theCharge);
      TObject::ShowMembers(R__insp, R__parent);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TrackObj(void *p) {
      return  p ? new(p) ::TrackObj : new ::TrackObj;
   }
   static void *newArray_TrackObj(Long_t nElements, void *p) {
      return p ? new(p) ::TrackObj[nElements] : new ::TrackObj[nElements];
   }
   // Wrapper around operator delete
   static void delete_TrackObj(void *p) {
      delete ((::TrackObj*)p);
   }
   static void deleteArray_TrackObj(void *p) {
      delete [] ((::TrackObj*)p);
   }
   static void destruct_TrackObj(void *p) {
      typedef ::TrackObj current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TrackObj

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

   UInt_t R__s, R__c;
   if (R__b.IsReading()) {
      Version_t R__v = R__b.ReadVersion(&R__s, &R__c); if (R__v) { }
      TrackObj::Streamer(R__b);
      R__b >> theMuonBits;
      R__b.CheckByteCount(R__s, R__c, MuonObj::IsA());
   } else {
      R__c = R__b.WriteVersion(MuonObj::IsA(), kTRUE);
      TrackObj::Streamer(R__b);
      R__b << theMuonBits;
      R__b.SetByteCount(R__c, kTRUE);
   }
}

//______________________________________________________________________________
void MuonObj::ShowMembers(TMemberInspector &R__insp, char *R__parent)
{
      // Inspect the data members of an object of class MuonObj.
      TClass *R__cl = ::MuonObj::IsA();
      Int_t R__ncp = strlen(R__parent);
      if (R__ncp || R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__parent, "theMuonBits", &theMuonBits);
      TrackObj::ShowMembers(R__insp, R__parent);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_MuonObj(void *p) {
      return  p ? new(p) ::MuonObj : new ::MuonObj;
   }
   static void *newArray_MuonObj(Long_t nElements, void *p) {
      return p ? new(p) ::MuonObj[nElements] : new ::MuonObj[nElements];
   }
   // Wrapper around operator delete
   static void delete_MuonObj(void *p) {
      delete ((::MuonObj*)p);
   }
   static void deleteArray_MuonObj(void *p) {
      delete [] ((::MuonObj*)p);
   }
   static void destruct_MuonObj(void *p) {
      typedef ::MuonObj current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::MuonObj

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

   UInt_t R__s, R__c;
   if (R__b.IsReading()) {
      Version_t R__v = R__b.ReadVersion(&R__s, &R__c); if (R__v) { }
      TObject::Streamer(R__b);
      R__b >> pt;
      R__b >> eta;
      R__b >> phi;
      R__b >> bx;
      R__b >> q;
      R__b.CheckByteCount(R__s, R__c, L1Obj::IsA());
   } else {
      R__c = R__b.WriteVersion(L1Obj::IsA(), kTRUE);
      TObject::Streamer(R__b);
      R__b << pt;
      R__b << eta;
      R__b << phi;
      R__b << bx;
      R__b << q;
      R__b.SetByteCount(R__c, kTRUE);
   }
}

//______________________________________________________________________________
void L1Obj::ShowMembers(TMemberInspector &R__insp, char *R__parent)
{
      // Inspect the data members of an object of class L1Obj.
      TClass *R__cl = ::L1Obj::IsA();
      Int_t R__ncp = strlen(R__parent);
      if (R__ncp || R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__parent, "pt", &pt);
      R__insp.Inspect(R__cl, R__parent, "eta", &eta);
      R__insp.Inspect(R__cl, R__parent, "phi", &phi);
      R__insp.Inspect(R__cl, R__parent, "bx", &bx);
      R__insp.Inspect(R__cl, R__parent, "q", &q);
      TObject::ShowMembers(R__insp, R__parent);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_L1Obj(void *p) {
      return  p ? new(p) ::L1Obj : new ::L1Obj;
   }
   static void *newArray_L1Obj(Long_t nElements, void *p) {
      return p ? new(p) ::L1Obj[nElements] : new ::L1Obj[nElements];
   }
   // Wrapper around operator delete
   static void delete_L1Obj(void *p) {
      delete ((::L1Obj*)p);
   }
   static void deleteArray_L1Obj(void *p) {
      delete [] ((::L1Obj*)p);
   }
   static void destruct_L1Obj(void *p) {
      typedef ::L1Obj current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::L1Obj

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

   UInt_t R__s, R__c;
   if (R__b.IsReading()) {
      Version_t R__v = R__b.ReadVersion(&R__s, &R__c); if (R__v) { }
      TObject::Streamer(R__b);
      {
         vector<L1Obj> &R__stl =  theL1Obj;
         R__stl.clear();
         int R__i, R__n;
         R__b >> R__n;
         R__stl.reserve(R__n);
         for (R__i = 0; R__i < R__n; R__i++) {
            L1Obj R__t;
            R__t.Streamer(R__b);
            R__stl.push_back(R__t);
         }
      }
      {
         vector<bool> &R__stl =  theL1Matching;
         R__stl.clear();
         int R__i, R__n;
         R__b >> R__n;
         R__stl.reserve(R__n);
         for (R__i = 0; R__i < R__n; R__i++) {
            bool R__t;
            R__b >> R__t;
            R__stl.push_back(R__t);
         }
      }
      R__b.CheckByteCount(R__s, R__c, L1ObjColl::IsA());
   } else {
      R__c = R__b.WriteVersion(L1ObjColl::IsA(), kTRUE);
      TObject::Streamer(R__b);
      {
         vector<L1Obj> &R__stl =  theL1Obj;
         int R__n=(&R__stl) ? int(R__stl.size()) : 0;
         R__b << R__n;
         if(R__n) {
            vector<L1Obj>::iterator R__k;
            for (R__k = R__stl.begin(); R__k != R__stl.end(); ++R__k) {
            ((L1Obj&)(*R__k)).Streamer(R__b);
            }
         }
      }
      {
         vector<bool> &R__stl =  theL1Matching;
         int R__n=(&R__stl) ? int(R__stl.size()) : 0;
         R__b << R__n;
         if(R__n) {
            vector<bool>::iterator R__k;
            for (R__k = R__stl.begin(); R__k != R__stl.end(); ++R__k) {
            R__b << (*R__k);
            }
         }
      }
      R__b.SetByteCount(R__c, kTRUE);
   }
}

//______________________________________________________________________________
void L1ObjColl::ShowMembers(TMemberInspector &R__insp, char *R__parent)
{
      // Inspect the data members of an object of class L1ObjColl.
      TClass *R__cl = ::L1ObjColl::IsA();
      Int_t R__ncp = strlen(R__parent);
      if (R__ncp || R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__parent, "theL1Obj", (void*)&theL1Obj);
      ::ROOT::GenericShowMembers("vector<L1Obj>", (void*)&theL1Obj, R__insp, strcat(R__parent,"theL1Obj."),false);
      R__parent[R__ncp] = 0;
      R__insp.Inspect(R__cl, R__parent, "theL1Matching", (void*)&theL1Matching);
      ::ROOT::GenericShowMembers("vector<bool>", (void*)&theL1Matching, R__insp, strcat(R__parent,"theL1Matching."),false);
      R__parent[R__ncp] = 0;
      TObject::ShowMembers(R__insp, R__parent);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_L1ObjColl(void *p) {
      return  p ? new(p) ::L1ObjColl : new ::L1ObjColl;
   }
   static void *newArray_L1ObjColl(Long_t nElements, void *p) {
      return p ? new(p) ::L1ObjColl[nElements] : new ::L1ObjColl[nElements];
   }
   // Wrapper around operator delete
   static void delete_L1ObjColl(void *p) {
      delete ((::L1ObjColl*)p);
   }
   static void deleteArray_L1ObjColl(void *p) {
      delete [] ((::L1ObjColl*)p);
   }
   static void destruct_L1ObjColl(void *p) {
      typedef ::L1ObjColl current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::L1ObjColl

namespace ROOT {
   void vectorlEL1ObjgR_ShowMembers(void *obj, TMemberInspector &R__insp, char *R__parent);
   static void vectorlEL1ObjgR_Dictionary();
   static void *new_vectorlEL1ObjgR(void *p = 0);
   static void *newArray_vectorlEL1ObjgR(Long_t size, void *p);
   static void delete_vectorlEL1ObjgR(void *p);
   static void deleteArray_vectorlEL1ObjgR(void *p);
   static void destruct_vectorlEL1ObjgR(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const vector<L1Obj>*)
   {
      vector<L1Obj> *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(vector<L1Obj>),0);
      static ::ROOT::TGenericClassInfo 
         instance("vector<L1Obj>", -2, "/afs/cern.ch/cms/sw/slc5_ia32_gcc434/lcg/root/5.22.00d-cms18/cint/cint/lib/prec_stl/vector", 49,
                  typeid(vector<L1Obj>), DefineBehavior(ptr, ptr),
                  0, &vectorlEL1ObjgR_Dictionary, isa_proxy, 0,
                  sizeof(vector<L1Obj>) );
      instance.SetNew(&new_vectorlEL1ObjgR);
      instance.SetNewArray(&newArray_vectorlEL1ObjgR);
      instance.SetDelete(&delete_vectorlEL1ObjgR);
      instance.SetDeleteArray(&deleteArray_vectorlEL1ObjgR);
      instance.SetDestructor(&destruct_vectorlEL1ObjgR);
      instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::Pushback< vector<L1Obj> >()));
      return &instance;
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const vector<L1Obj>*)0x0); R__UseDummy(_R__UNIQUE_(Init));

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

} // end of namespace ROOT

namespace ROOT {
   // Wrappers around operator new
   static void *new_vectorlEL1ObjgR(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) vector<L1Obj> : new vector<L1Obj>;
   }
   static void *newArray_vectorlEL1ObjgR(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) vector<L1Obj>[nElements] : new vector<L1Obj>[nElements];
   }
   // Wrapper around operator delete
   static void delete_vectorlEL1ObjgR(void *p) {
      delete ((vector<L1Obj>*)p);
   }
   static void deleteArray_vectorlEL1ObjgR(void *p) {
      delete [] ((vector<L1Obj>*)p);
   }
   static void destruct_vectorlEL1ObjgR(void *p) {
      typedef vector<L1Obj> current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class vector<L1Obj>

namespace ROOT {
   void vectorlEboolgR_ShowMembers(void *obj, TMemberInspector &R__insp, char *R__parent);
   static void vectorlEboolgR_Dictionary();
   static void *new_vectorlEboolgR(void *p = 0);
   static void *newArray_vectorlEboolgR(Long_t size, void *p);
   static void delete_vectorlEboolgR(void *p);
   static void deleteArray_vectorlEboolgR(void *p);
   static void destruct_vectorlEboolgR(void *p);

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

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

} // end of namespace ROOT

namespace ROOT {
   // Wrappers around operator new
   static void *new_vectorlEboolgR(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) vector<bool> : new vector<bool>;
   }
   static void *newArray_vectorlEboolgR(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) vector<bool>[nElements] : new vector<bool>[nElements];
   }
   // Wrapper around operator delete
   static void delete_vectorlEboolgR(void *p) {
      delete ((vector<bool>*)p);
   }
   static void deleteArray_vectorlEboolgR(void *p) {
      delete [] ((vector<bool>*)p);
   }
   static void destruct_vectorlEboolgR(void *p) {
      typedef vector<bool> current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class vector<bool>

/********************************************************
* rootMAnaDict.cc
* CAUTION: DON'T CHANGE THIS FILE. THIS FILE IS AUTOMATICALLY GENERATED
*          FROM HEADER FILES LISTED IN G__setup_cpp_environmentXXX().
*          CHANGE THOSE HEADER FILES AND REGENERATE THIS FILE.
********************************************************/

#ifdef G__MEMTEST
#undef malloc
#undef free
#endif

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

extern "C" void G__cpp_reset_tagtablerootMAnaDict();

extern "C" void G__set_cpp_environmentrootMAnaDict() {
  G__add_compiledheader("TObject.h");
  G__add_compiledheader("TMemberInspector.h");
  G__add_compiledheader("UserCode/L1RpcTriggerAnalysis/interface/EventObj.h");
  G__add_compiledheader("UserCode/L1RpcTriggerAnalysis/interface/TrackObj.h");
  G__add_compiledheader("UserCode/L1RpcTriggerAnalysis/interface/MuonObj.h");
  G__add_compiledheader("UserCode/L1RpcTriggerAnalysis/interface/L1Obj.h");
  G__add_compiledheader("UserCode/L1RpcTriggerAnalysis/interface/L1ObjColl.h");
  G__cpp_reset_tagtablerootMAnaDict();
}
#include <new>
extern "C" int G__cpp_dllrevrootMAnaDict() { return(30051515); }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


/* TrackObj */
static int G__rootMAnaDict_147_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TrackObj* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 4:
     //m: 4
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TrackObj(
(float) G__double(libp->para[0]), (float) G__double(libp->para[1])
, (float) G__double(libp->para[2]), (float) G__double(libp->para[3]));
     } else {
       p = new((void*) gvp) TrackObj(
(float) G__double(libp->para[0]), (float) G__double(libp->para[1])
, (float) G__double(libp->para[2]), (float) G__double(libp->para[3]));
     }
     break;
   case 3:
     //m: 3
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TrackObj(
(float) G__double(libp->para[0]), (float) G__double(libp->para[1])
, (float) G__double(libp->para[2]));
     } else {
       p = new((void*) gvp) TrackObj(
(float) G__double(libp->para[0]), (float) G__double(libp->para[1])
, (float) G__double(libp->para[2]));
     }
     break;
   case 2:
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TrackObj((float) G__double(libp->para[0]), (float) G__double(libp->para[1]));
     } else {
       p = new((void*) gvp) TrackObj((float) G__double(libp->para[0]), (float) G__double(libp->para[1]));
     }
     break;
   case 1:
     //m: 1
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TrackObj((float) G__double(libp->para[0]));
     } else {
       p = new((void*) gvp) TrackObj((float) G__double(libp->para[0]));
     }
     break;
   case 0:
     int n = G__getaryconstruct();
     if (n) {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TrackObj[n];
       } else {
         p = new((void*) gvp) TrackObj[n];
       }
     } else {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TrackObj;
       } else {
         p = new((void*) gvp) TrackObj;
       }
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__rootMAnaDictLN_TrackObj));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__rootMAnaDict_147_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TrackObj*) G__getstructoffset())->setKine((float) G__double(libp->para[0]), (float) G__double(libp->para[1])
, (float) G__double(libp->para[2]), (float) G__double(libp->para[3]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__rootMAnaDict_147_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const TrackObj*) G__getstructoffset())->pt());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__rootMAnaDict_147_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const TrackObj*) G__getstructoffset())->eta());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__rootMAnaDict_147_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const TrackObj*) G__getstructoffset())->phi());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__rootMAnaDict_147_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const TrackObj*) G__getstructoffset())->charge());
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

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

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

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

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

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


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

static int G__rootMAnaDict_148_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   MuonObj* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 4
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new MuonObj(
(float) G__double(libp->para[0]), (float) G__double(libp->para[1])
, (float) G__double(libp->para[2]), (float) G__double(libp->para[3]));
   } else {
     p = new((void*) gvp) MuonObj(
(float) G__double(libp->para[0]), (float) G__double(libp->para[1])
, (float) G__double(libp->para[2]), (float) G__double(libp->para[3]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__rootMAnaDictLN_MuonObj));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__rootMAnaDict_148_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((MuonObj*) G__getstructoffset())->setBits((bool) G__int(libp->para[0]), (bool) G__int(libp->para[1])
, (bool) G__int(libp->para[2]), (bool) G__int(libp->para[3])
, (bool) G__int(libp->para[4]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__rootMAnaDict_148_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const MuonObj*) G__getstructoffset())->isGlobal());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__rootMAnaDict_148_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const MuonObj*) G__getstructoffset())->isTracker());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__rootMAnaDict_148_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const MuonObj*) G__getstructoffset())->isOuter());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__rootMAnaDict_148_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const MuonObj*) G__getstructoffset())->isCalo());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__rootMAnaDict_148_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const MuonObj*) G__getstructoffset())->isMatched());
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

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

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

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

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

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


/* L1Obj */
static int G__rootMAnaDict_149_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((L1Obj*) G__getstructoffset())->isValid());
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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


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

static int G__rootMAnaDict_150_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((L1ObjColl*) G__getstructoffset())->set(*(vector<L1Obj>*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__rootMAnaDict_150_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((L1ObjColl*) G__getstructoffset())->set(*(vector<bool>*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__rootMAnaDict_150_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const vector<L1Obj>& obj = ((const L1ObjColl*) G__getstructoffset())->getL1Objs();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__rootMAnaDict_150_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const vector<bool>& obj = ((const L1ObjColl*) G__getstructoffset())->getL1ObjsMatching();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__rootMAnaDict_150_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      {
         const vector<L1Obj>* pobj;
         const vector<L1Obj> xobj = ((const L1ObjColl*) G__getstructoffset())->getL1ObjsMatched((double) G__double(libp->para[0]));
         pobj = new vector<L1Obj>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
      break;
   case 0:
      {
         const vector<L1Obj>* pobj;
         const vector<L1Obj> xobj = ((const L1ObjColl*) G__getstructoffset())->getL1ObjsMatched();
         pobj = new vector<L1Obj>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

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

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

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

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

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


/* Setting up global function */

/*********************************************************
* Member function Stub
*********************************************************/

/* EventObj */

/* TrackObj */

/* MuonObj */

/* L1Obj */

/* L1ObjColl */

/*********************************************************
* Global function Stub
*********************************************************/

/*********************************************************
* Get size of pointer to member function
*********************************************************/
class G__Sizep2memfuncrootMAnaDict {
 public:
  G__Sizep2memfuncrootMAnaDict(): p(&G__Sizep2memfuncrootMAnaDict::sizep2memfunc) {}
    size_t sizep2memfunc() { return(sizeof(p)); }
  private:
    size_t (G__Sizep2memfuncrootMAnaDict::*p)();
};

size_t G__get_sizep2memfuncrootMAnaDict()
{
  G__Sizep2memfuncrootMAnaDict a;
  G__setsizep2memfunc((int)a.sizep2memfunc());
  return((size_t)a.sizep2memfunc());
}


/*********************************************************
* virtual base class offset calculation interface
*********************************************************/

   /* Setting up class inheritance */

/*********************************************************
* Inheritance information setup/
*********************************************************/
extern "C" void G__cpp_setup_inheritancerootMAnaDict() {

   /* Setting up class inheritance */
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__rootMAnaDictLN_EventObj))) {
     EventObj *G__Lderived;
     G__Lderived=(EventObj*)0x1000;
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__rootMAnaDictLN_EventObj),G__get_linked_tagnum(&G__rootMAnaDictLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__rootMAnaDictLN_TrackObj))) {
     TrackObj *G__Lderived;
     G__Lderived=(TrackObj*)0x1000;
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__rootMAnaDictLN_TrackObj),G__get_linked_tagnum(&G__rootMAnaDictLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__rootMAnaDictLN_MuonObj))) {
     MuonObj *G__Lderived;
     G__Lderived=(MuonObj*)0x1000;
     {
       TrackObj *G__Lpbase=(TrackObj*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__rootMAnaDictLN_MuonObj),G__get_linked_tagnum(&G__rootMAnaDictLN_TrackObj),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__rootMAnaDictLN_MuonObj),G__get_linked_tagnum(&G__rootMAnaDictLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__rootMAnaDictLN_L1Obj))) {
     L1Obj *G__Lderived;
     G__Lderived=(L1Obj*)0x1000;
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__rootMAnaDictLN_L1Obj),G__get_linked_tagnum(&G__rootMAnaDictLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__rootMAnaDictLN_L1ObjColl))) {
     L1ObjColl *G__Lderived;
     G__Lderived=(L1ObjColl*)0x1000;
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__rootMAnaDictLN_L1ObjColl),G__get_linked_tagnum(&G__rootMAnaDictLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
}

/*********************************************************
* typedef information setup/
*********************************************************/
extern "C" void G__cpp_setup_typetablerootMAnaDict() {

   /* Setting up typedef entry */
   G__search_typename2("Version_t",115,-1,0,-1);
   G__setnewtype(-1,"Class version identifier (short)",0);
   G__search_typename2("vector<TSchemaHelper>",117,G__get_linked_tagnum(&G__rootMAnaDictLN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__rootMAnaDictLN_reverse_iteratorlEvectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__rootMAnaDictLN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__rootMAnaDictLN_reverse_iteratorlEvectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__rootMAnaDictLN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<ROOT::TSchemaHelper>",117,G__get_linked_tagnum(&G__rootMAnaDictLN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<L1Obj>",117,G__get_linked_tagnum(&G__rootMAnaDictLN_vectorlEL1ObjcOallocatorlEL1ObjgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__rootMAnaDictLN_reverse_iteratorlEvectorlEL1ObjcOallocatorlEL1ObjgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__rootMAnaDictLN_vectorlEL1ObjcOallocatorlEL1ObjgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__rootMAnaDictLN_reverse_iteratorlEvectorlEL1ObjcOallocatorlEL1ObjgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__rootMAnaDictLN_vectorlEL1ObjcOallocatorlEL1ObjgRsPgR));
   G__setnewtype(-1,NULL,0);
}

/*********************************************************
* Data Member information setup/
*********************************************************/

   /* Setting up class,struct,union tag member variable */

   /* EventObj */
static void G__setup_memvarEventObj(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__rootMAnaDictLN_EventObj));
   { EventObj *p; p=(EventObj*)0x1000; if (p) { }
   G__memvar_setup((void*)((long)(&p->bx)-(long)(p)),104,0,0,-1,-1,-1,1,"bx=",0,(char*)NULL);
   G__memvar_setup((void*)((long)(&p->id)-(long)(p)),104,0,0,-1,-1,-1,1,"id=",0,(char*)NULL);
   G__memvar_setup((void*)((long)(&p->lumi)-(long)(p)),104,0,0,-1,-1,-1,1,"lumi=",0,(char*)NULL);
   G__memvar_setup((void*)((long)(&p->run)-(long)(p)),104,0,0,-1,-1,-1,1,"run=",0,(char*)NULL);
   G__memvar_setup((void*)((long)(&p->time)-(long)(p)),109,0,0,-1,G__defined_typename("ULong64_t"),-1,1,"time=",0,(char*)NULL);
   G__memvar_setup((void*)((long)(&p->orbit)-(long)(p)),109,0,0,-1,G__defined_typename("ULong64_t"),-1,1,"orbit=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__rootMAnaDictLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TrackObj */
static void G__setup_memvarTrackObj(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__rootMAnaDictLN_TrackObj));
   { TrackObj *p; p=(TrackObj*)0x1000; if (p) { }
   G__memvar_setup((void*)0,102,0,0,-1,-1,-1,4,"thePt=",0,(char*)NULL);
   G__memvar_setup((void*)0,102,0,0,-1,-1,-1,4,"theEta=",0,(char*)NULL);
   G__memvar_setup((void*)0,102,0,0,-1,-1,-1,4,"thePhi=",0,(char*)NULL);
   G__memvar_setup((void*)0,102,0,0,-1,-1,-1,4,"theCharge=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__rootMAnaDictLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* MuonObj */
static void G__setup_memvarMuonObj(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__rootMAnaDictLN_MuonObj));
   { MuonObj *p; p=(MuonObj*)0x1000; if (p) { }
   G__memvar_setup((void*)0,104,0,0,-1,-1,-1,4,"theMuonBits=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__rootMAnaDictLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* L1Obj */
static void G__setup_memvarL1Obj(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__rootMAnaDictLN_L1Obj));
   { L1Obj *p; p=(L1Obj*)0x1000; if (p) { }
   G__memvar_setup((void*)((long)(&p->pt)-(long)(p)),102,0,0,-1,-1,-1,1,"pt=",0,(char*)NULL);
   G__memvar_setup((void*)((long)(&p->eta)-(long)(p)),102,0,0,-1,-1,-1,1,"eta=",0,(char*)NULL);
   G__memvar_setup((void*)((long)(&p->phi)-(long)(p)),102,0,0,-1,-1,-1,1,"phi=",0,(char*)NULL);
   G__memvar_setup((void*)((long)(&p->bx)-(long)(p)),105,0,0,-1,-1,-1,1,"bx=",0,(char*)NULL);
   G__memvar_setup((void*)((long)(&p->q)-(long)(p)),105,0,0,-1,-1,-1,1,"q=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__rootMAnaDictLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* L1ObjColl */
static void G__setup_memvarL1ObjColl(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__rootMAnaDictLN_L1ObjColl));
   { L1ObjColl *p; p=(L1ObjColl*)0x1000; if (p) { }
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__rootMAnaDictLN_vectorlEL1ObjcOallocatorlEL1ObjgRsPgR),G__defined_typename("vector<L1Obj>"),-1,4,"theL1Obj=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__rootMAnaDictLN_vectorlEboolcOallocatorlEboolgRsPgR),G__defined_typename("vector<bool>"),-1,4,"theL1Matching=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__rootMAnaDictLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}

extern "C" void G__cpp_setup_memvarrootMAnaDict() {
}
/***********************************************************
************************************************************
************************************************************
************************************************************
************************************************************
************************************************************
************************************************************
***********************************************************/

/*********************************************************
* Member function information setup for each class
*********************************************************/
static void G__setup_memfuncEventObj(void) {
   /* EventObj */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__rootMAnaDictLN_EventObj));
   G__memfunc_setup("Class",502,G__rootMAnaDict_146_0_1, 85, G__get_linked_tagnum(&G__rootMAnaDictLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) (TClass* (*)())(&EventObj::Class), 0);
   G__memfunc_setup("Class_Name",982,G__rootMAnaDict_146_0_2, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) (const char* (*)())(&EventObj::Class_Name), 0);
   G__memfunc_setup("Class_Version",1339,G__rootMAnaDict_146_0_3, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) (Version_t (*)())(&EventObj::Class_Version), 0);
   G__memfunc_setup("Dictionary",1046,G__rootMAnaDict_146_0_4, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) (void (*)())(&EventObj::Dictionary), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__rootMAnaDictLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"u 'TMemberInspector' - 1 - insp C - - 0 - parent", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__rootMAnaDict_146_0_8, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__rootMAnaDict_146_0_9, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) (const char* (*)())(&EventObj::DeclFileName), 0);
   G__memfunc_setup("ImplFileLine",1178,G__rootMAnaDict_146_0_10, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) (int (*)())(&EventObj::ImplFileLine), 0);
   G__memfunc_setup("ImplFileName",1171,G__rootMAnaDict_146_0_11, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) (const char* (*)())(&EventObj::ImplFileName), 0);
   G__memfunc_setup("DeclFileLine",1152,G__rootMAnaDict_146_0_12, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) (int (*)())(&EventObj::DeclFileLine), 0);
   // automatic default constructor
   G__memfunc_setup("EventObj", 797, G__rootMAnaDict_146_0_13, (int) ('i'), G__get_linked_tagnum(&G__rootMAnaDictLN_EventObj), -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   // automatic copy constructor
   G__memfunc_setup("EventObj", 797, G__rootMAnaDict_146_0_14, (int) ('i'), G__get_linked_tagnum(&G__rootMAnaDictLN_EventObj), -1, 0, 1, 1, 1, 0, "u 'EventObj' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~EventObj", 923, G__rootMAnaDict_146_0_15, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__rootMAnaDict_146_0_16, (int) ('u'), G__get_linked_tagnum(&G__rootMAnaDictLN_EventObj), -1, 1, 1, 1, 1, 0, "u 'EventObj' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTrackObj(void) {
   /* TrackObj */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__rootMAnaDictLN_TrackObj));
   G__memfunc_setup("TrackObj",784,G__rootMAnaDict_147_0_1, 105, G__get_linked_tagnum(&G__rootMAnaDictLN_TrackObj), -1, 0, 4, 1, 1, 0, 
"f - - 0 '0.' pt f - - 0 '0.' eta "
"f - - 0 '0.' phi f - - 0 '0.' charge", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setKine",723,G__rootMAnaDict_147_0_2, 121, -1, -1, 0, 4, 1, 1, 0, 
"f - - 0 - pt f - - 0 - eta "
"f - - 0 - phi f - - 0 - charge", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("pt",228,G__rootMAnaDict_147_0_3, 102, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("eta",314,G__rootMAnaDict_147_0_4, 102, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("phi",321,G__rootMAnaDict_147_0_5, 102, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("charge",618,G__rootMAnaDict_147_0_6, 102, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__rootMAnaDict_147_0_7, 85, G__get_linked_tagnum(&G__rootMAnaDictLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) (TClass* (*)())(&TrackObj::Class), 0);
   G__memfunc_setup("Class_Name",982,G__rootMAnaDict_147_0_8, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) (const char* (*)())(&TrackObj::Class_Name), 0);
   G__memfunc_setup("Class_Version",1339,G__rootMAnaDict_147_0_9, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) (Version_t (*)())(&TrackObj::Class_Version), 0);
   G__memfunc_setup("Dictionary",1046,G__rootMAnaDict_147_0_10, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) (void (*)())(&TrackObj::Dictionary), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__rootMAnaDictLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"u 'TMemberInspector' - 1 - insp C - - 0 - parent", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__rootMAnaDict_147_0_14, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__rootMAnaDict_147_0_15, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) (const char* (*)())(&TrackObj::DeclFileName), 0);
   G__memfunc_setup("ImplFileLine",1178,G__rootMAnaDict_147_0_16, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) (int (*)())(&TrackObj::ImplFileLine), 0);
   G__memfunc_setup("ImplFileName",1171,G__rootMAnaDict_147_0_17, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) (const char* (*)())(&TrackObj::ImplFileName), 0);
   G__memfunc_setup("DeclFileLine",1152,G__rootMAnaDict_147_0_18, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) (int (*)())(&TrackObj::DeclFileLine), 0);
   // automatic copy constructor
   G__memfunc_setup("TrackObj", 784, G__rootMAnaDict_147_0_19, (int) ('i'), G__get_linked_tagnum(&G__rootMAnaDictLN_TrackObj), -1, 0, 1, 1, 1, 0, "u 'TrackObj' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~TrackObj", 910, G__rootMAnaDict_147_0_20, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__rootMAnaDict_147_0_21, (int) ('u'), G__get_linked_tagnum(&G__rootMAnaDictLN_TrackObj), -1, 1, 1, 1, 1, 0, "u 'TrackObj' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncMuonObj(void) {
   /* MuonObj */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__rootMAnaDictLN_MuonObj));
   G__memfunc_setup("MuonObj",698,G__rootMAnaDict_148_0_1, 105, G__get_linked_tagnum(&G__rootMAnaDictLN_MuonObj), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MuonObj",698,G__rootMAnaDict_148_0_2, 105, G__get_linked_tagnum(&G__rootMAnaDictLN_MuonObj), -1, 0, 4, 1, 1, 0, 
"f - - 0 - pt f - - 0 - eta "
"f - - 0 - phi f - - 0 - charge", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("setBits",734,G__rootMAnaDict_148_0_3, 121, -1, -1, 0, 5, 1, 1, 0, 
"g - - 0 - isGlobal g - - 0 - isTracker "
"g - - 0 - isOuter g - - 0 - isCalo "
"g - - 0 - isMatched", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("isGlobal",813,G__rootMAnaDict_148_0_4, 103, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("isTracker",936,G__rootMAnaDict_148_0_5, 103, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("isOuter",747,G__rootMAnaDict_148_0_6, 103, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("isCalo",603,G__rootMAnaDict_148_0_7, 103, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("isMatched",914,G__rootMAnaDict_148_0_8, 103, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__rootMAnaDict_148_0_9, 85, G__get_linked_tagnum(&G__rootMAnaDictLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) (TClass* (*)())(&MuonObj::Class), 0);
   G__memfunc_setup("Class_Name",982,G__rootMAnaDict_148_0_10, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) (const char* (*)())(&MuonObj::Class_Name), 0);
   G__memfunc_setup("Class_Version",1339,G__rootMAnaDict_148_0_11, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) (Version_t (*)())(&MuonObj::Class_Version), 0);
   G__memfunc_setup("Dictionary",1046,G__rootMAnaDict_148_0_12, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) (void (*)())(&MuonObj::Dictionary), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__rootMAnaDictLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"u 'TMemberInspector' - 1 - insp C - - 0 - parent", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__rootMAnaDict_148_0_16, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__rootMAnaDict_148_0_17, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) (const char* (*)())(&MuonObj::DeclFileName), 0);
   G__memfunc_setup("ImplFileLine",1178,G__rootMAnaDict_148_0_18, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) (int (*)())(&MuonObj::ImplFileLine), 0);
   G__memfunc_setup("ImplFileName",1171,G__rootMAnaDict_148_0_19, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) (const char* (*)())(&MuonObj::ImplFileName), 0);
   G__memfunc_setup("DeclFileLine",1152,G__rootMAnaDict_148_0_20, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) (int (*)())(&MuonObj::DeclFileLine), 0);
   // automatic copy constructor
   G__memfunc_setup("MuonObj", 698, G__rootMAnaDict_148_0_21, (int) ('i'), G__get_linked_tagnum(&G__rootMAnaDictLN_MuonObj), -1, 0, 1, 1, 1, 0, "u 'MuonObj' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~MuonObj", 824, G__rootMAnaDict_148_0_22, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__rootMAnaDict_148_0_23, (int) ('u'), G__get_linked_tagnum(&G__rootMAnaDictLN_MuonObj), -1, 1, 1, 1, 1, 0, "u 'MuonObj' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncL1Obj(void) {
   /* L1Obj */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__rootMAnaDictLN_L1Obj));
   G__memfunc_setup("isValid",716,G__rootMAnaDict_149_0_1, 103, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("L1Obj",408,G__rootMAnaDict_149_0_2, 105, G__get_linked_tagnum(&G__rootMAnaDictLN_L1Obj), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__rootMAnaDict_149_0_3, 85, G__get_linked_tagnum(&G__rootMAnaDictLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) (TClass* (*)())(&L1Obj::Class), 0);
   G__memfunc_setup("Class_Name",982,G__rootMAnaDict_149_0_4, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) (const char* (*)())(&L1Obj::Class_Name), 0);
   G__memfunc_setup("Class_Version",1339,G__rootMAnaDict_149_0_5, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) (Version_t (*)())(&L1Obj::Class_Version), 0);
   G__memfunc_setup("Dictionary",1046,G__rootMAnaDict_149_0_6, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) (void (*)())(&L1Obj::Dictionary), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__rootMAnaDictLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"u 'TMemberInspector' - 1 - insp C - - 0 - parent", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__rootMAnaDict_149_0_10, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__rootMAnaDict_149_0_11, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) (const char* (*)())(&L1Obj::DeclFileName), 0);
   G__memfunc_setup("ImplFileLine",1178,G__rootMAnaDict_149_0_12, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) (int (*)())(&L1Obj::ImplFileLine), 0);
   G__memfunc_setup("ImplFileName",1171,G__rootMAnaDict_149_0_13, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) (const char* (*)())(&L1Obj::ImplFileName), 0);
   G__memfunc_setup("DeclFileLine",1152,G__rootMAnaDict_149_0_14, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) (int (*)())(&L1Obj::DeclFileLine), 0);
   // automatic copy constructor
   G__memfunc_setup("L1Obj", 408, G__rootMAnaDict_149_0_15, (int) ('i'), G__get_linked_tagnum(&G__rootMAnaDictLN_L1Obj), -1, 0, 1, 1, 1, 0, "u 'L1Obj' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~L1Obj", 534, G__rootMAnaDict_149_0_16, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__rootMAnaDict_149_0_17, (int) ('u'), G__get_linked_tagnum(&G__rootMAnaDictLN_L1Obj), -1, 1, 1, 1, 1, 0, "u 'L1Obj' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncL1ObjColl(void) {
   /* L1ObjColl */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__rootMAnaDictLN_L1ObjColl));
   G__memfunc_setup("L1ObjColl",802,G__rootMAnaDict_150_0_1, 105, G__get_linked_tagnum(&G__rootMAnaDictLN_L1ObjColl), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("set",332,G__rootMAnaDict_150_0_2, 121, -1, -1, 0, 1, 1, 1, 0, "u 'vector<L1Obj,allocator<L1Obj> >' 'vector<L1Obj>' 11 - obj", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("set",332,G__rootMAnaDict_150_0_3, 121, -1, -1, 0, 1, 1, 1, 0, "u 'vector<bool,allocator<bool> >' 'vector<bool>' 11 - comp", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getL1Objs",843,G__rootMAnaDict_150_0_4, 117, G__get_linked_tagnum(&G__rootMAnaDictLN_vectorlEL1ObjcOallocatorlEL1ObjgRsPgR), G__defined_typename("vector<L1Obj>"), 1, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getL1ObjsMatching",1654,G__rootMAnaDict_150_0_5, 117, G__get_linked_tagnum(&G__rootMAnaDictLN_vectorlEboolcOallocatorlEboolgRsPgR), G__defined_typename("vector<bool>"), 1, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getL1ObjsMatched",1537,G__rootMAnaDict_150_0_6, 117, G__get_linked_tagnum(&G__rootMAnaDictLN_vectorlEL1ObjcOallocatorlEL1ObjgRsPgR), G__defined_typename("vector<L1Obj>"), 0, 1, 1, 1, 8, "d - - 0 '0' ptMin", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__rootMAnaDict_150_0_7, 85, G__get_linked_tagnum(&G__rootMAnaDictLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) (TClass* (*)())(&L1ObjColl::Class), 0);
   G__memfunc_setup("Class_Name",982,G__rootMAnaDict_150_0_8, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) (const char* (*)())(&L1ObjColl::Class_Name), 0);
   G__memfunc_setup("Class_Version",1339,G__rootMAnaDict_150_0_9, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) (Version_t (*)())(&L1ObjColl::Class_Version), 0);
   G__memfunc_setup("Dictionary",1046,G__rootMAnaDict_150_0_10, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) (void (*)())(&L1ObjColl::Dictionary), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__rootMAnaDictLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"u 'TMemberInspector' - 1 - insp C - - 0 - parent", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__rootMAnaDict_150_0_14, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__rootMAnaDict_150_0_15, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) (const char* (*)())(&L1ObjColl::DeclFileName), 0);
   G__memfunc_setup("ImplFileLine",1178,G__rootMAnaDict_150_0_16, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) (int (*)())(&L1ObjColl::ImplFileLine), 0);
   G__memfunc_setup("ImplFileName",1171,G__rootMAnaDict_150_0_17, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) (const char* (*)())(&L1ObjColl::ImplFileName), 0);
   G__memfunc_setup("DeclFileLine",1152,G__rootMAnaDict_150_0_18, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) (int (*)())(&L1ObjColl::DeclFileLine), 0);
   // automatic copy constructor
   G__memfunc_setup("L1ObjColl", 802, G__rootMAnaDict_150_0_19, (int) ('i'), G__get_linked_tagnum(&G__rootMAnaDictLN_L1ObjColl), -1, 0, 1, 1, 1, 0, "u 'L1ObjColl' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~L1ObjColl", 928, G__rootMAnaDict_150_0_20, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__rootMAnaDict_150_0_21, (int) ('u'), G__get_linked_tagnum(&G__rootMAnaDictLN_L1ObjColl), -1, 1, 1, 1, 1, 0, "u 'L1ObjColl' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}


/*********************************************************
* Member function information setup
*********************************************************/
extern "C" void G__cpp_setup_memfuncrootMAnaDict() {
}

/*********************************************************
* Global variable information setup for each class
*********************************************************/
static void G__cpp_setup_global0() {

   /* Setting up global variables */
   G__resetplocal();

}

static void G__cpp_setup_global1() {

   G__resetglobalenv();
}
extern "C" void G__cpp_setup_globalrootMAnaDict() {
  G__cpp_setup_global0();
  G__cpp_setup_global1();
}

/*********************************************************
* Global function information setup for each class
*********************************************************/
static void G__cpp_setup_func0() {
   G__lastifuncposition();

}

static void G__cpp_setup_func1() {
}

static void G__cpp_setup_func2() {
}

static void G__cpp_setup_func3() {
}

static void G__cpp_setup_func4() {
}

static void G__cpp_setup_func5() {
}

static void G__cpp_setup_func6() {
}

static void G__cpp_setup_func7() {
}

static void G__cpp_setup_func8() {
}

static void G__cpp_setup_func9() {
}

static void G__cpp_setup_func10() {
}

static void G__cpp_setup_func11() {

   G__resetifuncposition();
}

extern "C" void G__cpp_setup_funcrootMAnaDict() {
  G__cpp_setup_func0();
  G__cpp_setup_func1();
  G__cpp_setup_func2();
  G__cpp_setup_func3();
  G__cpp_setup_func4();
  G__cpp_setup_func5();
  G__cpp_setup_func6();
  G__cpp_setup_func7();
  G__cpp_setup_func8();
  G__cpp_setup_func9();
  G__cpp_setup_func10();
  G__cpp_setup_func11();
}

/*********************************************************
* Class,struct,union,enum tag information setup
*********************************************************/
/* Setup class/struct taginfo */
G__linked_taginfo G__rootMAnaDictLN_TClass = { "TClass" , 99 , -1 };
G__linked_taginfo G__rootMAnaDictLN_TBuffer = { "TBuffer" , 99 , -1 };
G__linked_taginfo G__rootMAnaDictLN_TMemberInspector = { "TMemberInspector" , 99 , -1 };
G__linked_taginfo G__rootMAnaDictLN_TObject = { "TObject" , 99 , -1 };
G__linked_taginfo G__rootMAnaDictLN_vectorlEboolcOallocatorlEboolgRsPgR = { "vector<bool,allocator<bool> >" , 99 , -1 };
G__linked_taginfo G__rootMAnaDictLN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR = { "vector<ROOT::TSchemaHelper,allocator<ROOT::TSchemaHelper> >" , 99 , -1 };
G__linked_taginfo G__rootMAnaDictLN_reverse_iteratorlEvectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgRcLcLiteratorgR = { "reverse_iterator<vector<ROOT::TSchemaHelper,allocator<ROOT::TSchemaHelper> >::iterator>" , 99 , -1 };
G__linked_taginfo G__rootMAnaDictLN_EventObj = { "EventObj" , 115 , -1 };
G__linked_taginfo G__rootMAnaDictLN_TrackObj = { "TrackObj" , 99 , -1 };
G__linked_taginfo G__rootMAnaDictLN_MuonObj = { "MuonObj" , 99 , -1 };
G__linked_taginfo G__rootMAnaDictLN_L1Obj = { "L1Obj" , 115 , -1 };
G__linked_taginfo G__rootMAnaDictLN_L1ObjColl = { "L1ObjColl" , 99 , -1 };
G__linked_taginfo G__rootMAnaDictLN_vectorlEL1ObjcOallocatorlEL1ObjgRsPgR = { "vector<L1Obj,allocator<L1Obj> >" , 99 , -1 };
G__linked_taginfo G__rootMAnaDictLN_reverse_iteratorlEvectorlEL1ObjcOallocatorlEL1ObjgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<L1Obj,allocator<L1Obj> >::iterator>" , 99 , -1 };

/* Reset class/struct taginfo */
extern "C" void G__cpp_reset_tagtablerootMAnaDict() {
  G__rootMAnaDictLN_TClass.tagnum = -1 ;
  G__rootMAnaDictLN_TBuffer.tagnum = -1 ;
  G__rootMAnaDictLN_TMemberInspector.tagnum = -1 ;
  G__rootMAnaDictLN_TObject.tagnum = -1 ;
  G__rootMAnaDictLN_vectorlEboolcOallocatorlEboolgRsPgR.tagnum = -1 ;
  G__rootMAnaDictLN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR.tagnum = -1 ;
  G__rootMAnaDictLN_reverse_iteratorlEvectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__rootMAnaDictLN_EventObj.tagnum = -1 ;
  G__rootMAnaDictLN_TrackObj.tagnum = -1 ;
  G__rootMAnaDictLN_MuonObj.tagnum = -1 ;
  G__rootMAnaDictLN_L1Obj.tagnum = -1 ;
  G__rootMAnaDictLN_L1ObjColl.tagnum = -1 ;
  G__rootMAnaDictLN_vectorlEL1ObjcOallocatorlEL1ObjgRsPgR.tagnum = -1 ;
  G__rootMAnaDictLN_reverse_iteratorlEvectorlEL1ObjcOallocatorlEL1ObjgRsPgRcLcLiteratorgR.tagnum = -1 ;
}


extern "C" void G__cpp_setup_tagtablerootMAnaDict() {

   /* Setting up class,struct,union tag entry */
   G__get_linked_tagnum_fwd(&G__rootMAnaDictLN_TClass);
   G__get_linked_tagnum_fwd(&G__rootMAnaDictLN_TBuffer);
   G__get_linked_tagnum_fwd(&G__rootMAnaDictLN_TMemberInspector);
   G__get_linked_tagnum_fwd(&G__rootMAnaDictLN_TObject);
   G__get_linked_tagnum_fwd(&G__rootMAnaDictLN_vectorlEboolcOallocatorlEboolgRsPgR);
   G__get_linked_tagnum_fwd(&G__rootMAnaDictLN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR);
   G__get_linked_tagnum_fwd(&G__rootMAnaDictLN_reverse_iteratorlEvectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgRcLcLiteratorgR);
   G__tagtable_setup(G__get_linked_tagnum(&G__rootMAnaDictLN_EventObj),sizeof(EventObj),-1,28672,(char*)NULL,G__setup_memvarEventObj,G__setup_memfuncEventObj);
   G__tagtable_setup(G__get_linked_tagnum(&G__rootMAnaDictLN_TrackObj),sizeof(TrackObj),-1,29952,(char*)NULL,G__setup_memvarTrackObj,G__setup_memfuncTrackObj);
   G__tagtable_setup(G__get_linked_tagnum(&G__rootMAnaDictLN_MuonObj),sizeof(MuonObj),-1,62720,(char*)NULL,G__setup_memvarMuonObj,G__setup_memfuncMuonObj);
   G__tagtable_setup(G__get_linked_tagnum(&G__rootMAnaDictLN_L1Obj),sizeof(L1Obj),-1,28928,(char*)NULL,G__setup_memvarL1Obj,G__setup_memfuncL1Obj);
   G__tagtable_setup(G__get_linked_tagnum(&G__rootMAnaDictLN_L1ObjColl),sizeof(L1ObjColl),-1,29952,(char*)NULL,G__setup_memvarL1ObjColl,G__setup_memfuncL1ObjColl);
   G__get_linked_tagnum_fwd(&G__rootMAnaDictLN_vectorlEL1ObjcOallocatorlEL1ObjgRsPgR);
   G__get_linked_tagnum_fwd(&G__rootMAnaDictLN_reverse_iteratorlEvectorlEL1ObjcOallocatorlEL1ObjgRsPgRcLcLiteratorgR);
}
extern "C" void G__cpp_setuprootMAnaDict(void) {
  G__check_setup_version(30051515,"G__cpp_setuprootMAnaDict()");
  G__set_cpp_environmentrootMAnaDict();
  G__cpp_setup_tagtablerootMAnaDict();

  G__cpp_setup_inheritancerootMAnaDict();

  G__cpp_setup_typetablerootMAnaDict();

  G__cpp_setup_memvarrootMAnaDict();

  G__cpp_setup_memfuncrootMAnaDict();
  G__cpp_setup_globalrootMAnaDict();
  G__cpp_setup_funcrootMAnaDict();

   if(0==G__getsizep2memfunc()) G__get_sizep2memfuncrootMAnaDict();
  return;
}
class G__cpp_setup_initrootMAnaDict {
  public:
    G__cpp_setup_initrootMAnaDict() { G__add_setup_func("rootMAnaDict",(G__incsetup)(&G__cpp_setuprootMAnaDict)); G__call_setup_funcs(); }
   ~G__cpp_setup_initrootMAnaDict() { G__remove_setup_func("rootMAnaDict"); }
};
G__cpp_setup_initrootMAnaDict G__cpp_setup_initializerrootMAnaDict;

Revision:	1.3
Committed:	Thu Jul 15 13:02:50 2010 UTC (14 years, 9 months ago) by konec
Content type:	text/plain
Branch:	MAIN
CVS Tags:	V00-02-01, V00-02-00
Changes since 1.2:	+58 -35 lines
Log Message:	modyfikacje Malgosi