//
// File generated by rootcint at Sun Jul  2 07:56:03 2006.
// Do NOT change. Changes will be lost next time file is generated
//

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

#include "TTl1d_dict.h"
#include "TClass.h"
#include "TBuffer.h"
#include "TStreamerInfo.h"
#include "TMemberInspector.h"
#include "TError.h"

#ifndef G__ROOT
#define G__ROOT
#endif

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

#include "RtypesImp.h"

#include "TVectorProxy.h"

namespace ROOT {
   namespace Shadow {
   } // Of namespace ROOT::Shadow
} // Of namespace ROOT

namespace ROOT {
   void TPreFred_ShowMembers(void *obj, TMemberInspector &R__insp, char *R__parent);
   static void TPreFred_Dictionary();
   static TClass *TPreFred_IsA(const void*);
   static void *new_TPreFred(void *p = 0);
   static void *newArray_TPreFred(Long_t size);
   static void delete_TPreFred(void *p);
   static void deleteArray_TPreFred(void *p);
   static void destruct_TPreFred(void *p);

   // Function generating the singleton type initializer
   TGenericClassInfo *GenerateInitInstance(const TPreFred*)
   {
      TPreFred *ptr = 0;
      static ROOT::TGenericClassInfo 
         instance("TPreFred", "/data/nglas08/a/stdenis/stn614maxopt2jul06/include/Stntuple/data/TTl1d.hh", 11,
                  typeid(TPreFred), DefineBehavior(ptr, ptr),
                  0, &TPreFred_Dictionary, &TPreFred_IsA, 0,
                  sizeof(TPreFred) );
      instance.SetNew(&new_TPreFred);
      instance.SetNewArray(&newArray_TPreFred);
      instance.SetDelete(&delete_TPreFred);
      instance.SetDeleteArray(&deleteArray_TPreFred);
      instance.SetDestructor(&destruct_TPreFred);
      return &instance;
   }
   // Static variable to force the class initialization
   static ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstance((const TPreFred*)0x0); R__UseDummy(_R__UNIQUE_(Init));

   // Dictionary for non-ClassDef classes
   static void TPreFred_Dictionary() {
      ROOT::GenerateInitInstance((const TPreFred*)0x0)->GetClass();
   }

}

namespace ROOT {
   void TSumet_ShowMembers(void *obj, TMemberInspector &R__insp, char *R__parent);
   static void TSumet_Dictionary();
   static TClass *TSumet_IsA(const void*);
   static void *new_TSumet(void *p = 0);
   static void *newArray_TSumet(Long_t size);
   static void delete_TSumet(void *p);
   static void deleteArray_TSumet(void *p);
   static void destruct_TSumet(void *p);

   // Function generating the singleton type initializer
   TGenericClassInfo *GenerateInitInstance(const TSumet*)
   {
      TSumet *ptr = 0;
      static ROOT::TGenericClassInfo 
         instance("TSumet", "/data/nglas08/a/stdenis/stn614maxopt2jul06/include/Stntuple/data/TTl1d.hh", 34,
                  typeid(TSumet), DefineBehavior(ptr, ptr),
                  0, &TSumet_Dictionary, &TSumet_IsA, 0,
                  sizeof(TSumet) );
      instance.SetNew(&new_TSumet);
      instance.SetNewArray(&newArray_TSumet);
      instance.SetDelete(&delete_TSumet);
      instance.SetDeleteArray(&deleteArray_TSumet);
      instance.SetDestructor(&destruct_TSumet);
      return &instance;
   }
   // Static variable to force the class initialization
   static ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstance((const TSumet*)0x0); R__UseDummy(_R__UNIQUE_(Init));

   // Dictionary for non-ClassDef classes
   static void TSumet_Dictionary() {
      ROOT::GenerateInitInstance((const TSumet*)0x0)->GetClass();
   }

}

namespace ROOT {
   void TCaltrg_ShowMembers(void *obj, TMemberInspector &R__insp, char *R__parent);
   static void TCaltrg_Dictionary();
   static TClass *TCaltrg_IsA(const void*);
   static void *new_TCaltrg(void *p = 0);
   static void *newArray_TCaltrg(Long_t size);
   static void delete_TCaltrg(void *p);
   static void deleteArray_TCaltrg(void *p);
   static void destruct_TCaltrg(void *p);

   // Function generating the singleton type initializer
   TGenericClassInfo *GenerateInitInstance(const TCaltrg*)
   {
      TCaltrg *ptr = 0;
      static ROOT::TGenericClassInfo 
         instance("TCaltrg", "/data/nglas08/a/stdenis/stn614maxopt2jul06/include/Stntuple/data/TTl1d.hh", 51,
                  typeid(TCaltrg), DefineBehavior(ptr, ptr),
                  0, &TCaltrg_Dictionary, &TCaltrg_IsA, 0,
                  sizeof(TCaltrg) );
      instance.SetNew(&new_TCaltrg);
      instance.SetNewArray(&newArray_TCaltrg);
      instance.SetDelete(&delete_TCaltrg);
      instance.SetDeleteArray(&deleteArray_TCaltrg);
      instance.SetDestructor(&destruct_TCaltrg);
      return &instance;
   }
   // Static variable to force the class initialization
   static ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstance((const TCaltrg*)0x0); R__UseDummy(_R__UNIQUE_(Init));

   // Dictionary for non-ClassDef classes
   static void TCaltrg_Dictionary() {
      ROOT::GenerateInitInstance((const TCaltrg*)0x0)->GetClass();
   }

}

namespace ROOT {
   void TMutrg_ShowMembers(void *obj, TMemberInspector &R__insp, char *R__parent);
   static void TMutrg_Dictionary();
   static TClass *TMutrg_IsA(const void*);
   static void *new_TMutrg(void *p = 0);
   static void *newArray_TMutrg(Long_t size);
   static void delete_TMutrg(void *p);
   static void deleteArray_TMutrg(void *p);
   static void destruct_TMutrg(void *p);

   // Function generating the singleton type initializer
   TGenericClassInfo *GenerateInitInstance(const TMutrg*)
   {
      TMutrg *ptr = 0;
      static ROOT::TGenericClassInfo 
         instance("TMutrg", "/data/nglas08/a/stdenis/stn614maxopt2jul06/include/Stntuple/data/TTl1d.hh", 60,
                  typeid(TMutrg), DefineBehavior(ptr, ptr),
                  0, &TMutrg_Dictionary, &TMutrg_IsA, 0,
                  sizeof(TMutrg) );
      instance.SetNew(&new_TMutrg);
      instance.SetNewArray(&newArray_TMutrg);
      instance.SetDelete(&delete_TMutrg);
      instance.SetDeleteArray(&deleteArray_TMutrg);
      instance.SetDestructor(&destruct_TMutrg);
      return &instance;
   }
   // Static variable to force the class initialization
   static ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstance((const TMutrg*)0x0); R__UseDummy(_R__UNIQUE_(Init));

   // Dictionary for non-ClassDef classes
   static void TMutrg_Dictionary() {
      ROOT::GenerateInitInstance((const TMutrg*)0x0)->GetClass();
   }

}

namespace ROOT {
   void TTrktrg_ShowMembers(void *obj, TMemberInspector &R__insp, char *R__parent);
   static void TTrktrg_Dictionary();
   static TClass *TTrktrg_IsA(const void*);
   static void *new_TTrktrg(void *p = 0);
   static void *newArray_TTrktrg(Long_t size);
   static void delete_TTrktrg(void *p);
   static void deleteArray_TTrktrg(void *p);
   static void destruct_TTrktrg(void *p);

   // Function generating the singleton type initializer
   TGenericClassInfo *GenerateInitInstance(const TTrktrg*)
   {
      TTrktrg *ptr = 0;
      static ROOT::TGenericClassInfo 
         instance("TTrktrg", "/data/nglas08/a/stdenis/stn614maxopt2jul06/include/Stntuple/data/TTl1d.hh", 69,
                  typeid(TTrktrg), DefineBehavior(ptr, ptr),
                  0, &TTrktrg_Dictionary, &TTrktrg_IsA, 0,
                  sizeof(TTrktrg) );
      instance.SetNew(&new_TTrktrg);
      instance.SetNewArray(&newArray_TTrktrg);
      instance.SetDelete(&delete_TTrktrg);
      instance.SetDeleteArray(&deleteArray_TTrktrg);
      instance.SetDestructor(&destruct_TTrktrg);
      return &instance;
   }
   // Static variable to force the class initialization
   static ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstance((const TTrktrg*)0x0); R__UseDummy(_R__UNIQUE_(Init));

   // Dictionary for non-ClassDef classes
   static void TTrktrg_Dictionary() {
      ROOT::GenerateInitInstance((const TTrktrg*)0x0)->GetClass();
   }

}

namespace ROOT {
   void TBsctrg_ShowMembers(void *obj, TMemberInspector &R__insp, char *R__parent);
   static void TBsctrg_Dictionary();
   static TClass *TBsctrg_IsA(const void*);
   static void *new_TBsctrg(void *p = 0);
   static void *newArray_TBsctrg(Long_t size);
   static void delete_TBsctrg(void *p);
   static void deleteArray_TBsctrg(void *p);
   static void destruct_TBsctrg(void *p);

   // Function generating the singleton type initializer
   TGenericClassInfo *GenerateInitInstance(const TBsctrg*)
   {
      TBsctrg *ptr = 0;
      static ROOT::TGenericClassInfo 
         instance("TBsctrg", "/data/nglas08/a/stdenis/stn614maxopt2jul06/include/Stntuple/data/TTl1d.hh", 78,
                  typeid(TBsctrg), DefineBehavior(ptr, ptr),
                  0, &TBsctrg_Dictionary, &TBsctrg_IsA, 0,
                  sizeof(TBsctrg) );
      instance.SetNew(&new_TBsctrg);
      instance.SetNewArray(&newArray_TBsctrg);
      instance.SetDelete(&delete_TBsctrg);
      instance.SetDeleteArray(&deleteArray_TBsctrg);
      instance.SetDestructor(&destruct_TBsctrg);
      return &instance;
   }
   // Static variable to force the class initialization
   static ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstance((const TBsctrg*)0x0); R__UseDummy(_R__UNIQUE_(Init));

   // Dictionary for non-ClassDef classes
   static void TBsctrg_Dictionary() {
      ROOT::GenerateInitInstance((const TBsctrg*)0x0)->GetClass();
   }

}

namespace ROOT {
   void TMulti_ShowMembers(void *obj, TMemberInspector &R__insp, char *R__parent);
   static void TMulti_Dictionary();
   static TClass *TMulti_IsA(const void*);
   static void *new_TMulti(void *p = 0);
   static void *newArray_TMulti(Long_t size);
   static void delete_TMulti(void *p);
   static void deleteArray_TMulti(void *p);
   static void destruct_TMulti(void *p);

   // Function generating the singleton type initializer
   TGenericClassInfo *GenerateInitInstance(const TMulti*)
   {
      TMulti *ptr = 0;
      static ROOT::TGenericClassInfo 
         instance("TMulti", "/data/nglas08/a/stdenis/stn614maxopt2jul06/include/Stntuple/data/TTl1d.hh", 87,
                  typeid(TMulti), DefineBehavior(ptr, ptr),
                  0, &TMulti_Dictionary, &TMulti_IsA, 0,
                  sizeof(TMulti) );
      instance.SetNew(&new_TMulti);
      instance.SetNewArray(&newArray_TMulti);
      instance.SetDelete(&delete_TMulti);
      instance.SetDeleteArray(&deleteArray_TMulti);
      instance.SetDestructor(&destruct_TMulti);
      return &instance;
   }
   // Static variable to force the class initialization
   static ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstance((const TMulti*)0x0); R__UseDummy(_R__UNIQUE_(Init));

   // Dictionary for non-ClassDef classes
   static void TMulti_Dictionary() {
      ROOT::GenerateInitInstance((const TMulti*)0x0)->GetClass();
   }

}

namespace ROOT {
   void TTl1d_ShowMembers(void *obj, TMemberInspector &R__insp, char *R__parent);
   static void TTl1d_Dictionary();
   static TClass *TTl1d_IsA(const void*);
   static void *new_TTl1d(void *p = 0);
   static void *newArray_TTl1d(Long_t size);
   static void delete_TTl1d(void *p);
   static void deleteArray_TTl1d(void *p);
   static void destruct_TTl1d(void *p);

   // Function generating the singleton type initializer
   TGenericClassInfo *GenerateInitInstance(const TTl1d*)
   {
      TTl1d *ptr = 0;
      static ROOT::TGenericClassInfo 
         instance("TTl1d", "/data/nglas08/a/stdenis/stn614maxopt2jul06/include/Stntuple/data/TTl1d.hh", 96,
                  typeid(TTl1d), DefineBehavior(ptr, ptr),
                  0, &TTl1d_Dictionary, &TTl1d_IsA, 0,
                  sizeof(TTl1d) );
      instance.SetNew(&new_TTl1d);
      instance.SetNewArray(&newArray_TTl1d);
      instance.SetDelete(&delete_TTl1d);
      instance.SetDeleteArray(&deleteArray_TTl1d);
      instance.SetDestructor(&destruct_TTl1d);
      return &instance;
   }
   // Static variable to force the class initialization
   static ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstance((const TTl1d*)0x0); R__UseDummy(_R__UNIQUE_(Init));

   // Dictionary for non-ClassDef classes
   static void TTl1d_Dictionary() {
      ROOT::GenerateInitInstance((const TTl1d*)0x0)->GetClass();
   }

}

namespace ROOT {
   // Return the actual TClass for the object argument
   static TClass *TTl1d_IsA(const void *obj) {
      return GetROOT()->GetClass(typeid(*(::TTl1d*)obj));
   }
   // Wrappers around operator new
   static void *new_TTl1d(void *p) {
      return  p ? ::new((ROOT::TOperatorNewHelper*)p) ::TTl1d : new ::TTl1d;
   }
   static void *newArray_TTl1d(Long_t size) {
      return new ::TTl1d[size];
   }
   // Wrapper around operator delete
   static void delete_TTl1d(void *p) {
      delete ((::TTl1d*)p);
   }
   static void deleteArray_TTl1d(void *p) {
      delete [] ((::TTl1d*)p);
   }
   static void destruct_TTl1d(void *p) {
      typedef ::TTl1d current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TTl1d

namespace ROOT {
   // Return the actual TClass for the object argument
   static TClass *TPreFred_IsA(const void *obj) {
      return GetROOT()->GetClass(typeid(*(::TPreFred*)obj));
   }
   // Wrappers around operator new
   static void *new_TPreFred(void *p) {
      return  p ? ::new((ROOT::TOperatorNewHelper*)p) ::TPreFred : new ::TPreFred;
   }
   static void *newArray_TPreFred(Long_t size) {
      return new ::TPreFred[size];
   }
   // Wrapper around operator delete
   static void delete_TPreFred(void *p) {
      delete ((::TPreFred*)p);
   }
   static void deleteArray_TPreFred(void *p) {
      delete [] ((::TPreFred*)p);
   }
   static void destruct_TPreFred(void *p) {
      typedef ::TPreFred current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TPreFred

namespace ROOT {
   // Return the actual TClass for the object argument
   static TClass *TSumet_IsA(const void *obj) {
      return GetROOT()->GetClass(typeid(*(::TSumet*)obj));
   }
   // Wrappers around operator new
   static void *new_TSumet(void *p) {
      return  p ? ::new((ROOT::TOperatorNewHelper*)p) ::TSumet : new ::TSumet;
   }
   static void *newArray_TSumet(Long_t size) {
      return new ::TSumet[size];
   }
   // Wrapper around operator delete
   static void delete_TSumet(void *p) {
      delete ((::TSumet*)p);
   }
   static void deleteArray_TSumet(void *p) {
      delete [] ((::TSumet*)p);
   }
   static void destruct_TSumet(void *p) {
      typedef ::TSumet current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TSumet

namespace ROOT {
   // Return the actual TClass for the object argument
   static TClass *TCaltrg_IsA(const void *obj) {
      return GetROOT()->GetClass(typeid(*(::TCaltrg*)obj));
   }
   // Wrappers around operator new
   static void *new_TCaltrg(void *p) {
      return  p ? ::new((ROOT::TOperatorNewHelper*)p) ::TCaltrg : new ::TCaltrg;
   }
   static void *newArray_TCaltrg(Long_t size) {
      return new ::TCaltrg[size];
   }
   // Wrapper around operator delete
   static void delete_TCaltrg(void *p) {
      delete ((::TCaltrg*)p);
   }
   static void deleteArray_TCaltrg(void *p) {
      delete [] ((::TCaltrg*)p);
   }
   static void destruct_TCaltrg(void *p) {
      typedef ::TCaltrg current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TCaltrg

namespace ROOT {
   // Return the actual TClass for the object argument
   static TClass *TMutrg_IsA(const void *obj) {
      return GetROOT()->GetClass(typeid(*(::TMutrg*)obj));
   }
   // Wrappers around operator new
   static void *new_TMutrg(void *p) {
      return  p ? ::new((ROOT::TOperatorNewHelper*)p) ::TMutrg : new ::TMutrg;
   }
   static void *newArray_TMutrg(Long_t size) {
      return new ::TMutrg[size];
   }
   // Wrapper around operator delete
   static void delete_TMutrg(void *p) {
      delete ((::TMutrg*)p);
   }
   static void deleteArray_TMutrg(void *p) {
      delete [] ((::TMutrg*)p);
   }
   static void destruct_TMutrg(void *p) {
      typedef ::TMutrg current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TMutrg

namespace ROOT {
   // Return the actual TClass for the object argument
   static TClass *TTrktrg_IsA(const void *obj) {
      return GetROOT()->GetClass(typeid(*(::TTrktrg*)obj));
   }
   // Wrappers around operator new
   static void *new_TTrktrg(void *p) {
      return  p ? ::new((ROOT::TOperatorNewHelper*)p) ::TTrktrg : new ::TTrktrg;
   }
   static void *newArray_TTrktrg(Long_t size) {
      return new ::TTrktrg[size];
   }
   // Wrapper around operator delete
   static void delete_TTrktrg(void *p) {
      delete ((::TTrktrg*)p);
   }
   static void deleteArray_TTrktrg(void *p) {
      delete [] ((::TTrktrg*)p);
   }
   static void destruct_TTrktrg(void *p) {
      typedef ::TTrktrg current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TTrktrg

namespace ROOT {
   // Return the actual TClass for the object argument
   static TClass *TBsctrg_IsA(const void *obj) {
      return GetROOT()->GetClass(typeid(*(::TBsctrg*)obj));
   }
   // Wrappers around operator new
   static void *new_TBsctrg(void *p) {
      return  p ? ::new((ROOT::TOperatorNewHelper*)p) ::TBsctrg : new ::TBsctrg;
   }
   static void *newArray_TBsctrg(Long_t size) {
      return new ::TBsctrg[size];
   }
   // Wrapper around operator delete
   static void delete_TBsctrg(void *p) {
      delete ((::TBsctrg*)p);
   }
   static void deleteArray_TBsctrg(void *p) {
      delete [] ((::TBsctrg*)p);
   }
   static void destruct_TBsctrg(void *p) {
      typedef ::TBsctrg current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TBsctrg

namespace ROOT {
   // Return the actual TClass for the object argument
   static TClass *TMulti_IsA(const void *obj) {
      return GetROOT()->GetClass(typeid(*(::TMulti*)obj));
   }
   // Wrappers around operator new
   static void *new_TMulti(void *p) {
      return  p ? ::new((ROOT::TOperatorNewHelper*)p) ::TMulti : new ::TMulti;
   }
   static void *newArray_TMulti(Long_t size) {
      return new ::TMulti[size];
   }
   // Wrapper around operator delete
   static void delete_TMulti(void *p) {
      delete ((::TMulti*)p);
   }
   static void deleteArray_TMulti(void *p) {
      delete [] ((::TMulti*)p);
   }
   static void destruct_TMulti(void *p) {
      typedef ::TMulti current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TMulti

/********************************************************
* TTl1d_dict.cxx
********************************************************/

#ifdef G__MEMTEST
#undef malloc
#undef free
#endif

extern "C" void G__cpp_reset_tagtableTTl1d_dict();

extern "C" void G__set_cpp_environmentTTl1d_dict() {
  G__add_compiledheader("TROOT.h");
  G__add_compiledheader("TMemberInspector.h");
  G__add_compiledheader("TTl1d.hh");
  G__cpp_reset_tagtableTTl1d_dict();
}
class G__TTl1d_dictdOcxx_tag {};

void* operator new(size_t size,G__TTl1d_dictdOcxx_tag* p) {
  if(p && G__PVOID!=G__getgvp()) return((void*)p);
#ifndef G__ROOT
  return(malloc(size));
#else
  return(::operator new(size));
#endif
}

/* dummy, for exception */
#ifdef G__EH_DUMMY_DELETE
void operator delete(void *p,G__TTl1d_dictdOcxx_tag* x) {
  if((long)p==G__getgvp() && G__PVOID!=G__getgvp()) return;
#ifndef G__ROOT
  free(p);
#else
  ::operator delete(p);
#endif
}
#endif

static void G__operator_delete(void *p) {
  if((long)p==G__getgvp() && G__PVOID!=G__getgvp()) return;
#ifndef G__ROOT
  free(p);
#else
  ::operator delete(p);
#endif
}

void G__DELDMY_TTl1d_dictdOcxx() { G__operator_delete(0); }

extern "C" int G__cpp_dllrevTTl1d_dict() { return(30051515); }

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

/* TPreFred */
static int G__TTl1d_dict_183_1_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   TPreFred *p=NULL;
   if(G__getaryconstruct()) p=new TPreFred[G__getaryconstruct()];
   else p=::new((G__TTl1d_dictdOcxx_tag*)G__getgvp()) TPreFred;
      result7->obj.i = (long)p;
      result7->ref = (long)p;
      result7->type = 'u';
      result7->tagnum = G__get_linked_tagnum(&G__TTl1d_dictLN_TPreFred);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__TTl1d_dict_183_2_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__letint(result7,105,(long)((const TPreFred*)(G__getstructoffset()))->BunchCounter());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__TTl1d_dict_183_3_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__letint(result7,105,(long)((const TPreFred*)(G__getstructoffset()))->SlotNumber());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__TTl1d_dict_183_4_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__letint(result7,105,(long)((const TPreFred*)(G__getstructoffset()))->SerialNumber());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__TTl1d_dict_183_5_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__letint(result7,105,(long)((const TPreFred*)(G__getstructoffset()))->ModuleID());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__TTl1d_dict_183_6_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__letint(result7,105,(long)((const TPreFred*)(G__getstructoffset()))->Trig());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__TTl1d_dict_183_7_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__letint(result7,105,(long)((const TPreFred*)(G__getstructoffset()))->Word((Int_t)G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__TTl1d_dict_183_8_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash)
{
   TPreFred *p;
   void *xtmp = (void*)G__int(libp->para[0]);
   p=new TPreFred(*(TPreFred*)xtmp);
   result7->obj.i = (long)p;
   result7->ref = (long)p;
   result7->type = 'u';
   result7->tagnum = G__get_linked_tagnum(&G__TTl1d_dictLN_TPreFred);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TPreFred G__TTPreFred;
static int G__TTl1d_dict_183_9_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   if(0==G__getstructoffset()) return(1);
   if(G__getaryconstruct())
     if(G__PVOID==G__getgvp())
       delete[] (TPreFred *)(G__getstructoffset());
     else
       for(int i=G__getaryconstruct()-1;i>=0;i--)
         ((TPreFred *)((G__getstructoffset())+sizeof(TPreFred)*i))->~G__TTPreFred();
   else {
     long G__Xtmp=G__getgvp();
     G__setgvp(G__PVOID);
     ((TPreFred *)(G__getstructoffset()))->~G__TTPreFred();
     G__setgvp(G__Xtmp);
     G__operator_delete((void*)G__getstructoffset());
   }
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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


/* TSumet */
static int G__TTl1d_dict_184_1_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   TSumet *p=NULL;
   if(G__getaryconstruct()) p=new TSumet[G__getaryconstruct()];
   else p=::new((G__TTl1d_dictdOcxx_tag*)G__getgvp()) TSumet;
      result7->obj.i = (long)p;
      result7->ref = (long)p;
      result7->type = 'u';
      result7->tagnum = G__get_linked_tagnum(&G__TTl1d_dictLN_TSumet);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__TTl1d_dict_184_2_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__letint(result7,105,(long)((const TSumet*)(G__getstructoffset()))->Metsq());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__TTl1d_dict_184_3_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__letint(result7,105,(long)((const TSumet*)(G__getstructoffset()))->Et());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__TTl1d_dict_184_4_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__letint(result7,105,(long)((const TSumet*)(G__getstructoffset()))->Etx());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__TTl1d_dict_184_5_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__letint(result7,105,(long)((const TSumet*)(G__getstructoffset()))->Ety());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__TTl1d_dict_184_6_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
      G__letint(result7,105,(long)((const TSumet*)(G__getstructoffset()))->PrevEt());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__TTl1d_dict_184_7_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash)
{
   TSumet *p;
   void *xtmp = (void*)G__int(libp->para[0]);
   p=new TSumet(*(TSumet*)xtmp);
   result7->obj.i = (long)p;
   result7->ref = (long)p;
   result7->type = 'u';
   result7->tagnum = G__get_linked_tagnum(&G__TTl1d_dictLN_TSumet);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TSumet G__TTSumet;
static int G__TTl1d_dict_184_8_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   if(0==G__getstructoffset()) return(1);
   if(G__getaryconstruct())
     if(G__PVOID==G__getgvp())
       delete[] (TSumet *)(G__getstructoffset());
     else
       for(int i=G__getaryconstruct()-1;i>=0;i--)
         ((TSumet *)((G__getstructoffset())+sizeof(TSumet)*i))->~G__TTSumet();
   else {
     long G__Xtmp=G__getgvp();
     G__setgvp(G__PVOID);
     ((TSumet *)(G__getstructoffset()))->~G__TTSumet();
     G__setgvp(G__Xtmp);
     G__operator_delete((void*)G__getstructoffset());
   }
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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


/* TCaltrg */
static int G__TTl1d_dict_185_1_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   TCaltrg *p=NULL;
   if(G__getaryconstruct()) p=new TCaltrg[G__getaryconstruct()];
   else p=::new((G__TTl1d_dictdOcxx_tag*)G__getgvp()) TCaltrg;
      result7->obj.i = (long)p;
      result7->ref = (long)p;
      result7->type = 'u';
      result7->tagnum = G__get_linked_tagnum(&G__TTl1d_dictLN_TCaltrg);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__TTl1d_dict_185_2_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash)
{
   TCaltrg *p;
   void *xtmp = (void*)G__int(libp->para[0]);
   p=new TCaltrg(*(TCaltrg*)xtmp);
   result7->obj.i = (long)p;
   result7->ref = (long)p;
   result7->type = 'u';
   result7->tagnum = G__get_linked_tagnum(&G__TTl1d_dictLN_TCaltrg);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TCaltrg G__TTCaltrg;
static int G__TTl1d_dict_185_3_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   if(0==G__getstructoffset()) return(1);
   if(G__getaryconstruct())
     if(G__PVOID==G__getgvp())
       delete[] (TCaltrg *)(G__getstructoffset());
     else
       for(int i=G__getaryconstruct()-1;i>=0;i--)
         ((TCaltrg *)((G__getstructoffset())+sizeof(TCaltrg)*i))->~G__TTCaltrg();
   else {
     long G__Xtmp=G__getgvp();
     G__setgvp(G__PVOID);
     ((TCaltrg *)(G__getstructoffset()))->~G__TTCaltrg();
     G__setgvp(G__Xtmp);
     G__operator_delete((void*)G__getstructoffset());
   }
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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


/* TMutrg */
static int G__TTl1d_dict_186_1_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   TMutrg *p=NULL;
   if(G__getaryconstruct()) p=new TMutrg[G__getaryconstruct()];
   else p=::new((G__TTl1d_dictdOcxx_tag*)G__getgvp()) TMutrg;
      result7->obj.i = (long)p;
      result7->ref = (long)p;
      result7->type = 'u';
      result7->tagnum = G__get_linked_tagnum(&G__TTl1d_dictLN_TMutrg);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__TTl1d_dict_186_2_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash)
{
   TMutrg *p;
   void *xtmp = (void*)G__int(libp->para[0]);
   p=new TMutrg(*(TMutrg*)xtmp);
   result7->obj.i = (long)p;
   result7->ref = (long)p;
   result7->type = 'u';
   result7->tagnum = G__get_linked_tagnum(&G__TTl1d_dictLN_TMutrg);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TMutrg G__TTMutrg;
static int G__TTl1d_dict_186_3_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   if(0==G__getstructoffset()) return(1);
   if(G__getaryconstruct())
     if(G__PVOID==G__getgvp())
       delete[] (TMutrg *)(G__getstructoffset());
     else
       for(int i=G__getaryconstruct()-1;i>=0;i--)
         ((TMutrg *)((G__getstructoffset())+sizeof(TMutrg)*i))->~G__TTMutrg();
   else {
     long G__Xtmp=G__getgvp();
     G__setgvp(G__PVOID);
     ((TMutrg *)(G__getstructoffset()))->~G__TTMutrg();
     G__setgvp(G__Xtmp);
     G__operator_delete((void*)G__getstructoffset());
   }
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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


/* TTrktrg */
static int G__TTl1d_dict_187_1_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   TTrktrg *p=NULL;
   if(G__getaryconstruct()) p=new TTrktrg[G__getaryconstruct()];
   else p=::new((G__TTl1d_dictdOcxx_tag*)G__getgvp()) TTrktrg;
      result7->obj.i = (long)p;
      result7->ref = (long)p;
      result7->type = 'u';
      result7->tagnum = G__get_linked_tagnum(&G__TTl1d_dictLN_TTrktrg);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__TTl1d_dict_187_2_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash)
{
   TTrktrg *p;
   void *xtmp = (void*)G__int(libp->para[0]);
   p=new TTrktrg(*(TTrktrg*)xtmp);
   result7->obj.i = (long)p;
   result7->ref = (long)p;
   result7->type = 'u';
   result7->tagnum = G__get_linked_tagnum(&G__TTl1d_dictLN_TTrktrg);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TTrktrg G__TTTrktrg;
static int G__TTl1d_dict_187_3_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   if(0==G__getstructoffset()) return(1);
   if(G__getaryconstruct())
     if(G__PVOID==G__getgvp())
       delete[] (TTrktrg *)(G__getstructoffset());
     else
       for(int i=G__getaryconstruct()-1;i>=0;i--)
         ((TTrktrg *)((G__getstructoffset())+sizeof(TTrktrg)*i))->~G__TTTrktrg();
   else {
     long G__Xtmp=G__getgvp();
     G__setgvp(G__PVOID);
     ((TTrktrg *)(G__getstructoffset()))->~G__TTTrktrg();
     G__setgvp(G__Xtmp);
     G__operator_delete((void*)G__getstructoffset());
   }
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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


/* TBsctrg */
static int G__TTl1d_dict_188_1_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   TBsctrg *p=NULL;
   if(G__getaryconstruct()) p=new TBsctrg[G__getaryconstruct()];
   else p=::new((G__TTl1d_dictdOcxx_tag*)G__getgvp()) TBsctrg;
      result7->obj.i = (long)p;
      result7->ref = (long)p;
      result7->type = 'u';
      result7->tagnum = G__get_linked_tagnum(&G__TTl1d_dictLN_TBsctrg);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__TTl1d_dict_188_2_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash)
{
   TBsctrg *p;
   void *xtmp = (void*)G__int(libp->para[0]);
   p=new TBsctrg(*(TBsctrg*)xtmp);
   result7->obj.i = (long)p;
   result7->ref = (long)p;
   result7->type = 'u';
   result7->tagnum = G__get_linked_tagnum(&G__TTl1d_dictLN_TBsctrg);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TBsctrg G__TTBsctrg;
static int G__TTl1d_dict_188_3_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   if(0==G__getstructoffset()) return(1);
   if(G__getaryconstruct())
     if(G__PVOID==G__getgvp())
       delete[] (TBsctrg *)(G__getstructoffset());
     else
       for(int i=G__getaryconstruct()-1;i>=0;i--)
         ((TBsctrg *)((G__getstructoffset())+sizeof(TBsctrg)*i))->~G__TTBsctrg();
   else {
     long G__Xtmp=G__getgvp();
     G__setgvp(G__PVOID);
     ((TBsctrg *)(G__getstructoffset()))->~G__TTBsctrg();
     G__setgvp(G__Xtmp);
     G__operator_delete((void*)G__getstructoffset());
   }
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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


/* TMulti */
static int G__TTl1d_dict_189_1_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   TMulti *p=NULL;
   if(G__getaryconstruct()) p=new TMulti[G__getaryconstruct()];
   else p=::new((G__TTl1d_dictdOcxx_tag*)G__getgvp()) TMulti;
      result7->obj.i = (long)p;
      result7->ref = (long)p;
      result7->type = 'u';
      result7->tagnum = G__get_linked_tagnum(&G__TTl1d_dictLN_TMulti);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__TTl1d_dict_189_2_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash)
{
   TMulti *p;
   void *xtmp = (void*)G__int(libp->para[0]);
   p=new TMulti(*(TMulti*)xtmp);
   result7->obj.i = (long)p;
   result7->ref = (long)p;
   result7->type = 'u';
   result7->tagnum = G__get_linked_tagnum(&G__TTl1d_dictLN_TMulti);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TMulti G__TTMulti;
static int G__TTl1d_dict_189_3_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   if(0==G__getstructoffset()) return(1);
   if(G__getaryconstruct())
     if(G__PVOID==G__getgvp())
       delete[] (TMulti *)(G__getstructoffset());
     else
       for(int i=G__getaryconstruct()-1;i>=0;i--)
         ((TMulti *)((G__getstructoffset())+sizeof(TMulti)*i))->~G__TTMulti();
   else {
     long G__Xtmp=G__getgvp();
     G__setgvp(G__PVOID);
     ((TMulti *)(G__getstructoffset()))->~G__TTMulti();
     G__setgvp(G__Xtmp);
     G__operator_delete((void*)G__getstructoffset());
   }
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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


/* TTl1d */
static int G__TTl1d_dict_190_1_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   TTl1d *p=NULL;
   if(G__getaryconstruct()) p=new TTl1d[G__getaryconstruct()];
   else p=::new((G__TTl1d_dictdOcxx_tag*)G__getgvp()) TTl1d;
      result7->obj.i = (long)p;
      result7->ref = (long)p;
      result7->type = 'u';
      result7->tagnum = G__get_linked_tagnum(&G__TTl1d_dictLN_TTl1d);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__TTl1d_dict_190_2_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   G__letint(result7,85,(long)((TTl1d*)(G__getstructoffset()))->Sumet());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__TTl1d_dict_190_3_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   G__letint(result7,85,(long)((TTl1d*)(G__getstructoffset()))->Caltrg());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__TTl1d_dict_190_4_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   G__letint(result7,85,(long)((TTl1d*)(G__getstructoffset()))->Mutrg());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__TTl1d_dict_190_5_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   G__letint(result7,85,(long)((TTl1d*)(G__getstructoffset()))->Trktrg());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__TTl1d_dict_190_6_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   G__letint(result7,85,(long)((TTl1d*)(G__getstructoffset()))->Bsctrg());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__TTl1d_dict_190_7_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   G__letint(result7,85,(long)((TTl1d*)(G__getstructoffset()))->Multi());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__TTl1d_dict_190_8_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   G__letint(result7,85,(long)((TTl1d*)(G__getstructoffset()))->Module((Int_t)G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__TTl1d_dict_190_9_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   switch(libp->paran) {
   case 1:
      G__setnull(result7);
      ((const TTl1d*)(G__getstructoffset()))->Print((const char*)G__int(libp->para[0]));
      break;
   case 0:
      G__setnull(result7);
      ((const TTl1d*)(G__getstructoffset()))->Print();
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__TTl1d_dict_190_0_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash)
{
   TTl1d *p;
   void *xtmp = (void*)G__int(libp->para[0]);
   p=new TTl1d(*(TTl1d*)xtmp);
   result7->obj.i = (long)p;
   result7->ref = (long)p;
   result7->type = 'u';
   result7->tagnum = G__get_linked_tagnum(&G__TTl1d_dictLN_TTl1d);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TTl1d G__TTTl1d;
static int G__TTl1d_dict_190_1_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
   if(0==G__getstructoffset()) return(1);
   if(G__getaryconstruct())
     if(G__PVOID==G__getgvp())
       delete[] (TTl1d *)(G__getstructoffset());
     else
       for(int i=G__getaryconstruct()-1;i>=0;i--)
         ((TTl1d *)((G__getstructoffset())+sizeof(TTl1d)*i))->~G__TTTl1d();
   else {
     long G__Xtmp=G__getgvp();
     G__setgvp(G__PVOID);
     ((TTl1d *)(G__getstructoffset()))->~G__TTTl1d();
     G__setgvp(G__Xtmp);
     G__operator_delete((void*)G__getstructoffset());
   }
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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


/* Setting up global function */

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

/* TPreFred */

/* TSumet */

/* TCaltrg */

/* TMutrg */

/* TTrktrg */

/* TBsctrg */

/* TMulti */

/* TTl1d */

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

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

size_t G__get_sizep2memfuncTTl1d_dict()
{
  G__Sizep2memfuncTTl1d_dict 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_inheritanceTTl1d_dict() {

   /* Setting up class inheritance */
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__TTl1d_dictLN_TSumet))) {
     TSumet *G__Lderived;
     G__Lderived=(TSumet*)0x1000;
     {
       TPreFred *G__Lpbase=(TPreFred*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__TTl1d_dictLN_TSumet),G__get_linked_tagnum(&G__TTl1d_dictLN_TPreFred),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__TTl1d_dictLN_TCaltrg))) {
     TCaltrg *G__Lderived;
     G__Lderived=(TCaltrg*)0x1000;
     {
       TPreFred *G__Lpbase=(TPreFred*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__TTl1d_dictLN_TCaltrg),G__get_linked_tagnum(&G__TTl1d_dictLN_TPreFred),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__TTl1d_dictLN_TMutrg))) {
     TMutrg *G__Lderived;
     G__Lderived=(TMutrg*)0x1000;
     {
       TPreFred *G__Lpbase=(TPreFred*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__TTl1d_dictLN_TMutrg),G__get_linked_tagnum(&G__TTl1d_dictLN_TPreFred),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__TTl1d_dictLN_TTrktrg))) {
     TTrktrg *G__Lderived;
     G__Lderived=(TTrktrg*)0x1000;
     {
       TPreFred *G__Lpbase=(TPreFred*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__TTl1d_dictLN_TTrktrg),G__get_linked_tagnum(&G__TTl1d_dictLN_TPreFred),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__TTl1d_dictLN_TBsctrg))) {
     TBsctrg *G__Lderived;
     G__Lderived=(TBsctrg*)0x1000;
     {
       TPreFred *G__Lpbase=(TPreFred*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__TTl1d_dictLN_TBsctrg),G__get_linked_tagnum(&G__TTl1d_dictLN_TPreFred),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__TTl1d_dictLN_TMulti))) {
     TMulti *G__Lderived;
     G__Lderived=(TMulti*)0x1000;
     {
       TPreFred *G__Lpbase=(TPreFred*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__TTl1d_dictLN_TMulti),G__get_linked_tagnum(&G__TTl1d_dictLN_TPreFred),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
}

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

   /* Setting up typedef entry */
   G__search_typename2("Int_t",105,-1,0,
-1);
   G__setnewtype(-1,"Signed integer 4 bytes (int)",0);
   G__search_typename2("vector<TStreamerInfo*>",117,G__get_linked_tagnum(&G__TTl1d_dictLN_vectorlETStreamerInfomUcOallocatorlETStreamerInfomUgRsPgR),0,-1);
   G__setnewtype(-1,"// @(#)root/base:$Name: v4-00-08-patches $:$Id: TROOT.h,v 1.40 2004/02/19 00:11:18 rdm Exp $",0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__TTl1d_dictLN_reverse_iteratorlEvectorlETStreamerInfomUcOallocatorlETStreamerInfomUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__TTl1d_dictLN_vectorlETStreamerInfomUcOallocatorlETStreamerInfomUgRsPgR));
   G__setnewtype(-1,"// @(#)root/base:$Name: v4-00-08-patches $:$Id: TROOT.h,v 1.40 2004/02/19 00:11:18 rdm Exp $",0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__TTl1d_dictLN_reverse_iteratorlEvectorlETStreamerInfomUcOallocatorlETStreamerInfomUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__TTl1d_dictLN_vectorlETStreamerInfomUcOallocatorlETStreamerInfomUgRsPgR));
   G__setnewtype(-1,"// @(#)root/base:$Name: v4-00-08-patches $:$Id: TROOT.h,v 1.40 2004/02/19 00:11:18 rdm Exp $",0);
   G__search_typename2("vector<UInt_t>",117,G__get_linked_tagnum(&G__TTl1d_dictLN_vectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgR),0,-1);
   G__setnewtype(-1,"// @(#)root/base:$Name: v4-00-08-patches $:$Id: TROOT.h,v 1.40 2004/02/19 00:11:18 rdm Exp $",0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__TTl1d_dictLN_reverse_iteratorlEvectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__TTl1d_dictLN_vectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgR));
   G__setnewtype(-1,"// @(#)root/base:$Name: v4-00-08-patches $:$Id: TROOT.h,v 1.40 2004/02/19 00:11:18 rdm Exp $",0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__TTl1d_dictLN_reverse_iteratorlEvectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__TTl1d_dictLN_vectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgR));
   G__setnewtype(-1,"// @(#)root/base:$Name: v4-00-08-patches $:$Id: TROOT.h,v 1.40 2004/02/19 00:11:18 rdm Exp $",0);
   G__search_typename2("vector<unsigned int>",117,G__get_linked_tagnum(&G__TTl1d_dictLN_vectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgR),0,-1);
   G__setnewtype(-1,"// @(#)root/base:$Name: v4-00-08-patches $:$Id: TROOT.h,v 1.40 2004/02/19 00:11:18 rdm Exp $",0);
   G__search_typename2("vector<TString>",117,G__get_linked_tagnum(&G__TTl1d_dictLN_vectorlETStringcOallocatorlETStringgRsPgR),0,-1);
   G__setnewtype(-1,"// @(#)root/base:$Name: v4-00-08-patches $:$Id: TROOT.h,v 1.40 2004/02/19 00:11:18 rdm Exp $",0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__TTl1d_dictLN_reverse_iteratorlEvectorlETStringcOallocatorlETStringgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__TTl1d_dictLN_vectorlETStringcOallocatorlETStringgRsPgR));
   G__setnewtype(-1,"// @(#)root/base:$Name: v4-00-08-patches $:$Id: TROOT.h,v 1.40 2004/02/19 00:11:18 rdm Exp $",0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__TTl1d_dictLN_reverse_iteratorlEvectorlETStringcOallocatorlETStringgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__TTl1d_dictLN_vectorlETStringcOallocatorlETStringgRsPgR));
   G__setnewtype(-1,"// @(#)root/base:$Name: v4-00-08-patches $:$Id: TROOT.h,v 1.40 2004/02/19 00:11:18 rdm Exp $",0);
}

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

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

   /* TPreFred */
static void G__setup_memvarTPreFred(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__TTl1d_dictLN_TPreFred));
   { TPreFred *p; p=(TPreFred*)0x1000; if (p) { }
   G__memvar_setup((void*)NULL,105,0,0,-1,-1,-1,2,"fWord[4]=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TSumet */
static void G__setup_memvarTSumet(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__TTl1d_dictLN_TSumet));
   { TSumet *p; p=(TSumet*)0x1000; if (p) { }
   }
   G__tag_memvar_reset();
}


   /* TCaltrg */
static void G__setup_memvarTCaltrg(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__TTl1d_dictLN_TCaltrg));
   { TCaltrg *p; p=(TCaltrg*)0x1000; if (p) { }
   }
   G__tag_memvar_reset();
}


   /* TMutrg */
static void G__setup_memvarTMutrg(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__TTl1d_dictLN_TMutrg));
   { TMutrg *p; p=(TMutrg*)0x1000; if (p) { }
   }
   G__tag_memvar_reset();
}


   /* TTrktrg */
static void G__setup_memvarTTrktrg(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__TTl1d_dictLN_TTrktrg));
   { TTrktrg *p; p=(TTrktrg*)0x1000; if (p) { }
   }
   G__tag_memvar_reset();
}


   /* TBsctrg */
static void G__setup_memvarTBsctrg(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__TTl1d_dictLN_TBsctrg));
   { TBsctrg *p; p=(TBsctrg*)0x1000; if (p) { }
   }
   G__tag_memvar_reset();
}


   /* TMulti */
static void G__setup_memvarTMulti(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__TTl1d_dictLN_TMulti));
   { TMulti *p; p=(TMulti*)0x1000; if (p) { }
   }
   G__tag_memvar_reset();
}


   /* TTl1d */
static void G__setup_memvarTTl1d(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__TTl1d_dictLN_TTl1d));
   { TTl1d *p; p=(TTl1d*)0x1000; if (p) { }
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__TTl1d_dictLN_TTl1dcLcLdA),-1,-2,1,"kSumetGA=4",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__TTl1d_dictLN_TTl1dcLcLdA),-1,-2,1,"kCaltrgGA=5",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__TTl1d_dictLN_TTl1dcLcLdA),-1,-2,1,"kMutrgGA=6",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__TTl1d_dictLN_TTl1dcLcLdA),-1,-2,1,"kTrktrgGA=7",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__TTl1d_dictLN_TTl1dcLcLdA),-1,-2,1,"kBsctrgGA=10",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__TTl1d_dictLN_TTl1dcLcLdA),-1,-2,1,"kMultiGA=11",0,(char*)NULL);
   G__memvar_setup((void*)((long)(&p->fSumet)-(long)(p)),117,0,0,G__get_linked_tagnum(&G__TTl1d_dictLN_TSumet),-1,-1,1,"fSumet=",0,(char*)NULL);
   G__memvar_setup((void*)((long)(&p->fCaltrg)-(long)(p)),117,0,0,G__get_linked_tagnum(&G__TTl1d_dictLN_TCaltrg),-1,-1,1,"fCaltrg=",0,(char*)NULL);
   G__memvar_setup((void*)((long)(&p->fMutrg)-(long)(p)),117,0,0,G__get_linked_tagnum(&G__TTl1d_dictLN_TMutrg),-1,-1,1,"fMutrg=",0,(char*)NULL);
   G__memvar_setup((void*)((long)(&p->fTrktrg)-(long)(p)),117,0,0,G__get_linked_tagnum(&G__TTl1d_dictLN_TTrktrg),-1,-1,1,"fTrktrg=",0,(char*)NULL);
   G__memvar_setup((void*)((long)(&p->fBsctrg)-(long)(p)),117,0,0,G__get_linked_tagnum(&G__TTl1d_dictLN_TBsctrg),-1,-1,1,"fBsctrg=",0,(char*)NULL);
   G__memvar_setup((void*)((long)(&p->fMulti)-(long)(p)),117,0,0,G__get_linked_tagnum(&G__TTl1d_dictLN_TMulti),-1,-1,1,"fMulti=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}

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

/*********************************************************
* Member function information setup for each class
*********************************************************/
static void G__setup_memfuncTPreFred(void) {
   /* TPreFred */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__TTl1d_dictLN_TPreFred));
   G__memfunc_setup("TPreFred",764,G__TTl1d_dict_183_1_0,105,G__get_linked_tagnum(&G__TTl1d_dictLN_TPreFred),-1,0,0,1,1,0,"",(char*)NULL,(void*)NULL,0);
   G__memfunc_setup("BunchCounter",1232,G__TTl1d_dict_183_2_0,105,-1,G__defined_typename("Int_t"),0,0,1,1,8,"",(char*)NULL,(void*)NULL,0);
   G__memfunc_setup("SlotNumber",1035,G__TTl1d_dict_183_3_0,105,-1,G__defined_typename("Int_t"),0,0,1,1,8,"",(char*)NULL,(void*)NULL,0);
   G__memfunc_setup("SerialNumber",1225,G__TTl1d_dict_183_4_0,105,-1,G__defined_typename("Int_t"),0,0,1,1,8,"",(char*)NULL,(void*)NULL,0);
   G__memfunc_setup("ModuleID",755,G__TTl1d_dict_183_5_0,105,-1,G__defined_typename("Int_t"),0,0,1,1,8,"",(char*)NULL,(void*)NULL,0);
   G__memfunc_setup("Trig",406,G__TTl1d_dict_183_6_0,105,-1,G__defined_typename("Int_t"),0,0,1,1,8,"",(char*)NULL,(void*)NULL,0);
   G__memfunc_setup("Word",412,G__TTl1d_dict_183_7_0,105,-1,G__defined_typename("Int_t"),0,1,1,1,8,"i - 'Int_t' 0 - i",(char*)NULL,(void*)NULL,0);
   // automatic copy constructor
   G__memfunc_setup("TPreFred",764,G__TTl1d_dict_183_8_0,(int)('i'),G__get_linked_tagnum(&G__TTl1d_dictLN_TPreFred),-1,0,1,1,1,0,"u 'TPreFred' - 11 - -",(char*)NULL,(void*)NULL,0);
   // automatic destructor
   G__memfunc_setup("~TPreFred",890,G__TTl1d_dict_183_9_0,(int)('y'),-1,-1,0,0,1,1,0,"",(char*)NULL,(void*)NULL,0);
   // automatic assignment operator
   G__memfunc_setup("operator=",937,G__TTl1d_dict_183_0_1,(int)('u'),G__get_linked_tagnum(&G__TTl1d_dictLN_TPreFred),-1,1,1,1,1,0,"u 'TPreFred' - 11 - -",(char*)NULL,(void*)NULL,0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTSumet(void) {
   /* TSumet */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__TTl1d_dictLN_TSumet));
   G__memfunc_setup("TSumet",610,G__TTl1d_dict_184_1_0,105,G__get_linked_tagnum(&G__TTl1d_dictLN_TSumet),-1,0,0,1,1,0,"",(char*)NULL,(void*)NULL,0);
   G__memfunc_setup("Metsq",522,G__TTl1d_dict_184_2_0,105,-1,G__defined_typename("Int_t"),0,0,1,1,8,"",(char*)NULL,(void*)NULL,0);
   G__memfunc_setup("Et",185,G__TTl1d_dict_184_3_0,105,-1,G__defined_typename("Int_t"),0,0,1,1,8,"",(char*)NULL,(void*)NULL,0);
   G__memfunc_setup("Etx",305,G__TTl1d_dict_184_4_0,105,-1,G__defined_typename("Int_t"),0,0,1,1,8,"",(char*)NULL,(void*)NULL,0);
   G__memfunc_setup("Ety",306,G__TTl1d_dict_184_5_0,105,-1,G__defined_typename("Int_t"),0,0,1,1,8,"",(char*)NULL,(void*)NULL,0);
   G__memfunc_setup("PrevEt",598,G__TTl1d_dict_184_6_0,105,-1,G__defined_typename("Int_t"),0,0,1,1,8,"",(char*)NULL,(void*)NULL,0);
   // automatic copy constructor
   G__memfunc_setup("TSumet",610,G__TTl1d_dict_184_7_0,(int)('i'),G__get_linked_tagnum(&G__TTl1d_dictLN_TSumet),-1,0,1,1,1,0,"u 'TSumet' - 11 - -",(char*)NULL,(void*)NULL,0);
   // automatic destructor
   G__memfunc_setup("~TSumet",736,G__TTl1d_dict_184_8_0,(int)('y'),-1,-1,0,0,1,1,0,"",(char*)NULL,(void*)NULL,0);
   // automatic assignment operator
   G__memfunc_setup("operator=",937,G__TTl1d_dict_184_9_0,(int)('u'),G__get_linked_tagnum(&G__TTl1d_dictLN_TSumet),-1,1,1,1,1,0,"u 'TSumet' - 11 - -",(char*)NULL,(void*)NULL,0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTCaltrg(void) {
   /* TCaltrg */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__TTl1d_dictLN_TCaltrg));
   G__memfunc_setup("TCaltrg",689,G__TTl1d_dict_185_1_0,105,G__get_linked_tagnum(&G__TTl1d_dictLN_TCaltrg),-1,0,0,1,1,0,"",(char*)NULL,(void*)NULL,0);
   // automatic copy constructor
   G__memfunc_setup("TCaltrg",689,G__TTl1d_dict_185_2_0,(int)('i'),G__get_linked_tagnum(&G__TTl1d_dictLN_TCaltrg),-1,0,1,1,1,0,"u 'TCaltrg' - 11 - -",(char*)NULL,(void*)NULL,0);
   // automatic destructor
   G__memfunc_setup("~TCaltrg",815,G__TTl1d_dict_185_3_0,(int)('y'),-1,-1,0,0,1,1,0,"",(char*)NULL,(void*)NULL,0);
   // automatic assignment operator
   G__memfunc_setup("operator=",937,G__TTl1d_dict_185_4_0,(int)('u'),G__get_linked_tagnum(&G__TTl1d_dictLN_TCaltrg),-1,1,1,1,1,0,"u 'TCaltrg' - 11 - -",(char*)NULL,(void*)NULL,0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTMutrg(void) {
   /* TMutrg */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__TTl1d_dictLN_TMutrg));
   G__memfunc_setup("TMutrg",611,G__TTl1d_dict_186_1_0,105,G__get_linked_tagnum(&G__TTl1d_dictLN_TMutrg),-1,0,0,1,1,0,"",(char*)NULL,(void*)NULL,0);
   // automatic copy constructor
   G__memfunc_setup("TMutrg",611,G__TTl1d_dict_186_2_0,(int)('i'),G__get_linked_tagnum(&G__TTl1d_dictLN_TMutrg),-1,0,1,1,1,0,"u 'TMutrg' - 11 - -",(char*)NULL,(void*)NULL,0);
   // automatic destructor
   G__memfunc_setup("~TMutrg",737,G__TTl1d_dict_186_3_0,(int)('y'),-1,-1,0,0,1,1,0,"",(char*)NULL,(void*)NULL,0);
   // automatic assignment operator
   G__memfunc_setup("operator=",937,G__TTl1d_dict_186_4_0,(int)('u'),G__get_linked_tagnum(&G__TTl1d_dictLN_TMutrg),-1,1,1,1,1,0,"u 'TMutrg' - 11 - -",(char*)NULL,(void*)NULL,0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTTrktrg(void) {
   /* TTrktrg */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__TTl1d_dictLN_TTrktrg));
   G__memfunc_setup("TTrktrg",722,G__TTl1d_dict_187_1_0,105,G__get_linked_tagnum(&G__TTl1d_dictLN_TTrktrg),-1,0,0,1,1,0,"",(char*)NULL,(void*)NULL,0);
   // automatic copy constructor
   G__memfunc_setup("TTrktrg",722,G__TTl1d_dict_187_2_0,(int)('i'),G__get_linked_tagnum(&G__TTl1d_dictLN_TTrktrg),-1,0,1,1,1,0,"u 'TTrktrg' - 11 - -",(char*)NULL,(void*)NULL,0);
   // automatic destructor
   G__memfunc_setup("~TTrktrg",848,G__TTl1d_dict_187_3_0,(int)('y'),-1,-1,0,0,1,1,0,"",(char*)NULL,(void*)NULL,0);
   // automatic assignment operator
   G__memfunc_setup("operator=",937,G__TTl1d_dict_187_4_0,(int)('u'),G__get_linked_tagnum(&G__TTl1d_dictLN_TTrktrg),-1,1,1,1,1,0,"u 'TTrktrg' - 11 - -",(char*)NULL,(void*)NULL,0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTBsctrg(void) {
   /* TBsctrg */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__TTl1d_dictLN_TBsctrg));
   G__memfunc_setup("TBsctrg",697,G__TTl1d_dict_188_1_0,105,G__get_linked_tagnum(&G__TTl1d_dictLN_TBsctrg),-1,0,0,1,1,0,"",(char*)NULL,(void*)NULL,0);
   // automatic copy constructor
   G__memfunc_setup("TBsctrg",697,G__TTl1d_dict_188_2_0,(int)('i'),G__get_linked_tagnum(&G__TTl1d_dictLN_TBsctrg),-1,0,1,1,1,0,"u 'TBsctrg' - 11 - -",(char*)NULL,(void*)NULL,0);
   // automatic destructor
   G__memfunc_setup("~TBsctrg",823,G__TTl1d_dict_188_3_0,(int)('y'),-1,-1,0,0,1,1,0,"",(char*)NULL,(void*)NULL,0);
   // automatic assignment operator
   G__memfunc_setup("operator=",937,G__TTl1d_dict_188_4_0,(int)('u'),G__get_linked_tagnum(&G__TTl1d_dictLN_TBsctrg),-1,1,1,1,1,0,"u 'TBsctrg' - 11 - -",(char*)NULL,(void*)NULL,0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTMulti(void) {
   /* TMulti */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__TTl1d_dictLN_TMulti));
   G__memfunc_setup("TMulti",607,G__TTl1d_dict_189_1_0,105,G__get_linked_tagnum(&G__TTl1d_dictLN_TMulti),-1,0,0,1,1,0,"",(char*)NULL,(void*)NULL,0);
   // automatic copy constructor
   G__memfunc_setup("TMulti",607,G__TTl1d_dict_189_2_0,(int)('i'),G__get_linked_tagnum(&G__TTl1d_dictLN_TMulti),-1,0,1,1,1,0,"u 'TMulti' - 11 - -",(char*)NULL,(void*)NULL,0);
   // automatic destructor
   G__memfunc_setup("~TMulti",733,G__TTl1d_dict_189_3_0,(int)('y'),-1,-1,0,0,1,1,0,"",(char*)NULL,(void*)NULL,0);
   // automatic assignment operator
   G__memfunc_setup("operator=",937,G__TTl1d_dict_189_4_0,(int)('u'),G__get_linked_tagnum(&G__TTl1d_dictLN_TMulti),-1,1,1,1,1,0,"u 'TMulti' - 11 - -",(char*)NULL,(void*)NULL,0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTTl1d(void) {
   /* TTl1d */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__TTl1d_dictLN_TTl1d));
   G__memfunc_setup("TTl1d",425,G__TTl1d_dict_190_1_0,105,G__get_linked_tagnum(&G__TTl1d_dictLN_TTl1d),-1,0,0,1,1,0,"",(char*)NULL,(void*)NULL,0);
   G__memfunc_setup("Sumet",526,G__TTl1d_dict_190_2_0,85,G__get_linked_tagnum(&G__TTl1d_dictLN_TSumet),-1,0,0,1,1,0,"",(char*)NULL,(void*)NULL,0);
   G__memfunc_setup("Caltrg",605,G__TTl1d_dict_190_3_0,85,G__get_linked_tagnum(&G__TTl1d_dictLN_TCaltrg),-1,0,0,1,1,0,"",(char*)NULL,(void*)NULL,0);
   G__memfunc_setup("Mutrg",527,G__TTl1d_dict_190_4_0,85,G__get_linked_tagnum(&G__TTl1d_dictLN_TMutrg),-1,0,0,1,1,0,"",(char*)NULL,(void*)NULL,0);
   G__memfunc_setup("Trktrg",638,G__TTl1d_dict_190_5_0,85,G__get_linked_tagnum(&G__TTl1d_dictLN_TTrktrg),-1,0,0,1,1,0,"",(char*)NULL,(void*)NULL,0);
   G__memfunc_setup("Bsctrg",613,G__TTl1d_dict_190_6_0,85,G__get_linked_tagnum(&G__TTl1d_dictLN_TBsctrg),-1,0,0,1,1,0,"",(char*)NULL,(void*)NULL,0);
   G__memfunc_setup("Multi",523,G__TTl1d_dict_190_7_0,85,G__get_linked_tagnum(&G__TTl1d_dictLN_TMulti),-1,0,0,1,1,0,"",(char*)NULL,(void*)NULL,0);
   G__memfunc_setup("Module",614,G__TTl1d_dict_190_8_0,85,G__get_linked_tagnum(&G__TTl1d_dictLN_TPreFred),-1,0,1,1,1,0,"i - 'Int_t' 0 - slot",(char*)NULL,(void*)NULL,0);
   G__memfunc_setup("Print",525,G__TTl1d_dict_190_9_0,121,-1,-1,0,1,1,1,8,"C - - 10 \"\" Opt",(char*)NULL,(void*)NULL,0);
   // automatic copy constructor
   G__memfunc_setup("TTl1d",425,G__TTl1d_dict_190_0_1,(int)('i'),G__get_linked_tagnum(&G__TTl1d_dictLN_TTl1d),-1,0,1,1,1,0,"u 'TTl1d' - 11 - -",(char*)NULL,(void*)NULL,0);
   // automatic destructor
   G__memfunc_setup("~TTl1d",551,G__TTl1d_dict_190_1_1,(int)('y'),-1,-1,0,0,1,1,0,"",(char*)NULL,(void*)NULL,0);
   // automatic assignment operator
   G__memfunc_setup("operator=",937,G__TTl1d_dict_190_2_1,(int)('u'),G__get_linked_tagnum(&G__TTl1d_dictLN_TTl1d),-1,1,1,1,1,0,"u 'TTl1d' - 11 - -",(char*)NULL,(void*)NULL,0);
   G__tag_memfunc_reset();
}


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

/*********************************************************
* 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_globalTTl1d_dict() {
  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_funcTTl1d_dict() {
  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__TTl1d_dictLN_vectorlETStreamerInfomUcOallocatorlETStreamerInfomUgRsPgR = { "vector<TStreamerInfo*,allocator<TStreamerInfo*> >" , 99 , -1 };
G__linked_taginfo G__TTl1d_dictLN_reverse_iteratorlEvectorlETStreamerInfomUcOallocatorlETStreamerInfomUgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<TStreamerInfo*,allocator<TStreamerInfo*> >::iterator>" , 99 , -1 };
G__linked_taginfo G__TTl1d_dictLN_vectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgR = { "vector<unsigned int,allocator<unsigned int> >" , 99 , -1 };
G__linked_taginfo G__TTl1d_dictLN_reverse_iteratorlEvectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<unsigned int,allocator<unsigned int> >::iterator>" , 99 , -1 };
G__linked_taginfo G__TTl1d_dictLN_vectorlETStringcOallocatorlETStringgRsPgR = { "vector<TString,allocator<TString> >" , 99 , -1 };
G__linked_taginfo G__TTl1d_dictLN_reverse_iteratorlEvectorlETStringcOallocatorlETStringgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<TString,allocator<TString> >::iterator>" , 99 , -1 };
G__linked_taginfo G__TTl1d_dictLN_TPreFred = { "TPreFred" , 99 , -1 };
G__linked_taginfo G__TTl1d_dictLN_TSumet = { "TSumet" , 99 , -1 };
G__linked_taginfo G__TTl1d_dictLN_TCaltrg = { "TCaltrg" , 99 , -1 };
G__linked_taginfo G__TTl1d_dictLN_TMutrg = { "TMutrg" , 99 , -1 };
G__linked_taginfo G__TTl1d_dictLN_TTrktrg = { "TTrktrg" , 99 , -1 };
G__linked_taginfo G__TTl1d_dictLN_TBsctrg = { "TBsctrg" , 99 , -1 };
G__linked_taginfo G__TTl1d_dictLN_TMulti = { "TMulti" , 99 , -1 };
G__linked_taginfo G__TTl1d_dictLN_TTl1d = { "TTl1d" , 99 , -1 };
G__linked_taginfo G__TTl1d_dictLN_TTl1dcLcLdA = { "TTl1d::$" , 101 , -1 };

/* Reset class/struct taginfo */
extern "C" void G__cpp_reset_tagtableTTl1d_dict() {
  G__TTl1d_dictLN_vectorlETStreamerInfomUcOallocatorlETStreamerInfomUgRsPgR.tagnum = -1 ;
  G__TTl1d_dictLN_reverse_iteratorlEvectorlETStreamerInfomUcOallocatorlETStreamerInfomUgRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__TTl1d_dictLN_vectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgR.tagnum = -1 ;
  G__TTl1d_dictLN_reverse_iteratorlEvectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__TTl1d_dictLN_vectorlETStringcOallocatorlETStringgRsPgR.tagnum = -1 ;
  G__TTl1d_dictLN_reverse_iteratorlEvectorlETStringcOallocatorlETStringgRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__TTl1d_dictLN_TPreFred.tagnum = -1 ;
  G__TTl1d_dictLN_TSumet.tagnum = -1 ;
  G__TTl1d_dictLN_TCaltrg.tagnum = -1 ;
  G__TTl1d_dictLN_TMutrg.tagnum = -1 ;
  G__TTl1d_dictLN_TTrktrg.tagnum = -1 ;
  G__TTl1d_dictLN_TBsctrg.tagnum = -1 ;
  G__TTl1d_dictLN_TMulti.tagnum = -1 ;
  G__TTl1d_dictLN_TTl1d.tagnum = -1 ;
  G__TTl1d_dictLN_TTl1dcLcLdA.tagnum = -1 ;
}


extern "C" void G__cpp_setup_tagtableTTl1d_dict() {

   /* Setting up class,struct,union tag entry */
   G__get_linked_tagnum(&G__TTl1d_dictLN_vectorlETStreamerInfomUcOallocatorlETStreamerInfomUgRsPgR);
   G__get_linked_tagnum(&G__TTl1d_dictLN_reverse_iteratorlEvectorlETStreamerInfomUcOallocatorlETStreamerInfomUgRsPgRcLcLiteratorgR);
   G__get_linked_tagnum(&G__TTl1d_dictLN_vectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgR);
   G__get_linked_tagnum(&G__TTl1d_dictLN_reverse_iteratorlEvectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgRcLcLiteratorgR);
   G__get_linked_tagnum(&G__TTl1d_dictLN_vectorlETStringcOallocatorlETStringgRsPgR);
   G__get_linked_tagnum(&G__TTl1d_dictLN_reverse_iteratorlEvectorlETStringcOallocatorlETStringgRsPgRcLcLiteratorgR);
   G__tagtable_setup(G__get_linked_tagnum(&G__TTl1d_dictLN_TPreFred),sizeof(TPreFred),-1,1280,(char*)NULL,G__setup_memvarTPreFred,G__setup_memfuncTPreFred);
   G__tagtable_setup(G__get_linked_tagnum(&G__TTl1d_dictLN_TSumet),sizeof(TSumet),-1,1280,(char*)NULL,G__setup_memvarTSumet,G__setup_memfuncTSumet);
   G__tagtable_setup(G__get_linked_tagnum(&G__TTl1d_dictLN_TCaltrg),sizeof(TCaltrg),-1,1280,(char*)NULL,G__setup_memvarTCaltrg,G__setup_memfuncTCaltrg);
   G__tagtable_setup(G__get_linked_tagnum(&G__TTl1d_dictLN_TMutrg),sizeof(TMutrg),-1,1280,(char*)NULL,G__setup_memvarTMutrg,G__setup_memfuncTMutrg);
   G__tagtable_setup(G__get_linked_tagnum(&G__TTl1d_dictLN_TTrktrg),sizeof(TTrktrg),-1,1280,(char*)NULL,G__setup_memvarTTrktrg,G__setup_memfuncTTrktrg);
   G__tagtable_setup(G__get_linked_tagnum(&G__TTl1d_dictLN_TBsctrg),sizeof(TBsctrg),-1,1280,(char*)NULL,G__setup_memvarTBsctrg,G__setup_memfuncTBsctrg);
   G__tagtable_setup(G__get_linked_tagnum(&G__TTl1d_dictLN_TMulti),sizeof(TMulti),-1,1280,(char*)NULL,G__setup_memvarTMulti,G__setup_memfuncTMulti);
   G__tagtable_setup(G__get_linked_tagnum(&G__TTl1d_dictLN_TTl1d),sizeof(TTl1d),-1,1280,(char*)NULL,G__setup_memvarTTl1d,G__setup_memfuncTTl1d);
   G__get_linked_tagnum(&G__TTl1d_dictLN_TTl1dcLcLdA);
}
extern "C" void G__cpp_setupTTl1d_dict(void) {
  G__check_setup_version(30051515,"G__cpp_setupTTl1d_dict()");
  G__set_cpp_environmentTTl1d_dict();
  G__cpp_setup_tagtableTTl1d_dict();

  G__cpp_setup_inheritanceTTl1d_dict();

  G__cpp_setup_typetableTTl1d_dict();

  G__cpp_setup_memvarTTl1d_dict();

  G__cpp_setup_memfuncTTl1d_dict();
  G__cpp_setup_globalTTl1d_dict();
  G__cpp_setup_funcTTl1d_dict();

   if(0==G__getsizep2memfunc()) G__get_sizep2memfuncTTl1d_dict();
  return;
}
class G__cpp_setup_initTTl1d_dict {
  public:
    G__cpp_setup_initTTl1d_dict() { G__add_setup_func("TTl1d_dict",(G__incsetup)(&G__cpp_setupTTl1d_dict)); G__call_setup_funcs(); }
   ~G__cpp_setup_initTTl1d_dict() { G__remove_setup_func("TTl1d_dict"); }
};
G__cpp_setup_initTTl1d_dict G__cpp_setup_initializerTTl1d_dict;