G__Tree.cxx

Go to the documentation of this file.

//
// File generated by core/utils/src/rootcint_tmp at Wed Apr 20 13:35:21 2011

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

#define R__DICTIONARY_FILENAME treedItreedIsrcdIG__Tree
#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 "G__Tree.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"

#include "TBuffer.h"
#include "TVirtualObject.h"
#include <vector>
#include "TSchemaHelper.h"


// START OF SHADOWS

namespace ROOT {
   namespace Shadow {
      #if !(defined(R__ACCESS_IN_SYMBOL) || defined(R__USE_SHADOW_CLASS))
      typedef ::TIndArray TIndArray;
      #else
      class TIndArray  {
         public:
         //friend XX;
         // To force the creation of a virtual table, throw just in case.
         virtual ~TIndArray() throw() {};
         unsigned int fElems; //Number of elements stored in the array
         unsigned int fCapacity; //!Capacity of the array
         unsigned char* fArr; //[fElems] The array
      };
      #endif

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

namespace ROOT {
   void TTree_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TTree(void *p = 0);
   static void *newArray_TTree(Long_t size, void *p);
   static void delete_TTree(void *p);
   static void deleteArray_TTree(void *p);
   static void destruct_TTree(void *p);
   static void directoryAutoAdd_TTree(void *p, TDirectory *dir);
   static void streamer_TTree(TBuffer &buf, void *obj);

   // Schema evolution read functions
   static void read_TTree_0( char* target, TVirtualObject *oldObj )
   {
      //--- Automatically generated variables ---
      static TClassRef cls("TTree");
      static Long_t offset_fDefaultEntryOffsetLen = cls->GetDataMemberOffset("fDefaultEntryOffsetLen");
      Int_t& fDefaultEntryOffsetLen = *(Int_t*)(target+offset_fDefaultEntryOffsetLen);
      TTree* newObj = (TTree*)target;
      // Supress warning message.
      if (oldObj) {}

      if (newObj) {}

      //--- User's code ---
      fDefaultEntryOffsetLen = 1000; 
   }

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TTree*)
   {
      ::TTree *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TTree >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TTree", ::TTree::Class_Version(), "include/TTree.h", 91,
                  typeid(::TTree), DefineBehavior(ptr, ptr),
                  &::TTree::Dictionary, isa_proxy, 1,
                  sizeof(::TTree) );
      instance.SetNew(&new_TTree);
      instance.SetNewArray(&newArray_TTree);
      instance.SetDelete(&delete_TTree);
      instance.SetDeleteArray(&deleteArray_TTree);
      instance.SetDestructor(&destruct_TTree);
      instance.SetDirectoryAutoAdd(&directoryAutoAdd_TTree);
      instance.SetStreamerFunc(&streamer_TTree);

      ROOT::TSchemaHelper* rule;

      // the io read rules
      std::vector<ROOT::TSchemaHelper> readrules(1);
      rule = &readrules[0];
      rule->fSourceClass = "TTree";
      rule->fTarget      = "fDefaultEntryOffsetLen";
      rule->fSource      = "";
      rule->fFunctionPtr = (void *)G__func2void( read_TTree_0);
      rule->fCode        = " fDefaultEntryOffsetLen = 1000; ";
      rule->fVersion     = "[-16]";
      instance.SetReadRules( readrules );
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TTree*)
   {
      return GenerateInitInstanceLocal((::TTree*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TTree*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TBranch_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TBranch(void *p = 0);
   static void *newArray_TBranch(Long_t size, void *p);
   static void delete_TBranch(void *p);
   static void deleteArray_TBranch(void *p);
   static void destruct_TBranch(void *p);
   static void streamer_TBranch(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TBranch*)
   {
      ::TBranch *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TBranch >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TBranch", ::TBranch::Class_Version(), "include/TBranch.h", 57,
                  typeid(::TBranch), DefineBehavior(ptr, ptr),
                  &::TBranch::Dictionary, isa_proxy, 1,
                  sizeof(::TBranch) );
      instance.SetNew(&new_TBranch);
      instance.SetNewArray(&newArray_TBranch);
      instance.SetDelete(&delete_TBranch);
      instance.SetDeleteArray(&deleteArray_TBranch);
      instance.SetDestructor(&destruct_TBranch);
      instance.SetStreamerFunc(&streamer_TBranch);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TBranch*)
   {
      return GenerateInitInstanceLocal((::TBranch*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TBranch*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TBasket_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TBasket(void *p = 0);
   static void *newArray_TBasket(Long_t size, void *p);
   static void delete_TBasket(void *p);
   static void deleteArray_TBasket(void *p);
   static void destruct_TBasket(void *p);
   static void streamer_TBasket(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TBasket*)
   {
      ::TBasket *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TBasket >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TBasket", ::TBasket::Class_Version(), "include/TBasket.h", 38,
                  typeid(::TBasket), DefineBehavior(ptr, ptr),
                  &::TBasket::Dictionary, isa_proxy, 1,
                  sizeof(::TBasket) );
      instance.SetNew(&new_TBasket);
      instance.SetNewArray(&newArray_TBasket);
      instance.SetDelete(&delete_TBasket);
      instance.SetDeleteArray(&deleteArray_TBasket);
      instance.SetDestructor(&destruct_TBasket);
      instance.SetStreamerFunc(&streamer_TBasket);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TBasket*)
   {
      return GenerateInitInstanceLocal((::TBasket*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TBasket*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TBufferSQL_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TBufferSQL(void *p = 0);
   static void *newArray_TBufferSQL(Long_t size, void *p);
   static void delete_TBufferSQL(void *p);
   static void deleteArray_TBufferSQL(void *p);
   static void destruct_TBufferSQL(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TBufferSQL*)
   {
      ::TBufferSQL *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TBufferSQL >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TBufferSQL", ::TBufferSQL::Class_Version(), "include/TBufferSQL.h", 34,
                  typeid(::TBufferSQL), DefineBehavior(ptr, ptr),
                  &::TBufferSQL::Dictionary, isa_proxy, 4,
                  sizeof(::TBufferSQL) );
      instance.SetNew(&new_TBufferSQL);
      instance.SetNewArray(&newArray_TBufferSQL);
      instance.SetDelete(&delete_TBufferSQL);
      instance.SetDeleteArray(&deleteArray_TBufferSQL);
      instance.SetDestructor(&destruct_TBufferSQL);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TBufferSQL*)
   {
      return GenerateInitInstanceLocal((::TBufferSQL*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TBufferSQL*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TBasketSQL_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TBasketSQL(void *p = 0);
   static void *newArray_TBasketSQL(Long_t size, void *p);
   static void delete_TBasketSQL(void *p);
   static void deleteArray_TBasketSQL(void *p);
   static void destruct_TBasketSQL(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TBasketSQL*)
   {
      ::TBasketSQL *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TBasketSQL >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TBasketSQL", ::TBasketSQL::Class_Version(), "include/TBasketSQL.h", 31,
                  typeid(::TBasketSQL), DefineBehavior(ptr, ptr),
                  &::TBasketSQL::Dictionary, isa_proxy, 4,
                  sizeof(::TBasketSQL) );
      instance.SetNew(&new_TBasketSQL);
      instance.SetNewArray(&newArray_TBasketSQL);
      instance.SetDelete(&delete_TBasketSQL);
      instance.SetDeleteArray(&deleteArray_TBasketSQL);
      instance.SetDestructor(&destruct_TBasketSQL);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TBasketSQL*)
   {
      return GenerateInitInstanceLocal((::TBasketSQL*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TBasketSQL*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TBranchElement_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TBranchElement(void *p = 0);
   static void *newArray_TBranchElement(Long_t size, void *p);
   static void delete_TBranchElement(void *p);
   static void deleteArray_TBranchElement(void *p);
   static void destruct_TBranchElement(void *p);
   static void streamer_TBranchElement(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TBranchElement*)
   {
      ::TBranchElement *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TBranchElement >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TBranchElement", ::TBranchElement::Class_Version(), "include/TBranchElement.h", 52,
                  typeid(::TBranchElement), DefineBehavior(ptr, ptr),
                  &::TBranchElement::Dictionary, isa_proxy, 1,
                  sizeof(::TBranchElement) );
      instance.SetNew(&new_TBranchElement);
      instance.SetNewArray(&newArray_TBranchElement);
      instance.SetDelete(&delete_TBranchElement);
      instance.SetDeleteArray(&deleteArray_TBranchElement);
      instance.SetDestructor(&destruct_TBranchElement);
      instance.SetStreamerFunc(&streamer_TBranchElement);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TBranchElement*)
   {
      return GenerateInitInstanceLocal((::TBranchElement*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TBranchElement*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TVirtualBranchBrowsable_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TVirtualBranchBrowsable(void *p);
   static void deleteArray_TVirtualBranchBrowsable(void *p);
   static void destruct_TVirtualBranchBrowsable(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TVirtualBranchBrowsable*)
   {
      ::TVirtualBranchBrowsable *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TVirtualBranchBrowsable >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TVirtualBranchBrowsable", ::TVirtualBranchBrowsable::Class_Version(), "include/TBranchBrowsable.h", 33,
                  typeid(::TVirtualBranchBrowsable), DefineBehavior(ptr, ptr),
                  &::TVirtualBranchBrowsable::Dictionary, isa_proxy, 4,
                  sizeof(::TVirtualBranchBrowsable) );
      instance.SetDelete(&delete_TVirtualBranchBrowsable);
      instance.SetDeleteArray(&deleteArray_TVirtualBranchBrowsable);
      instance.SetDestructor(&destruct_TVirtualBranchBrowsable);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TVirtualBranchBrowsable*)
   {
      return GenerateInitInstanceLocal((::TVirtualBranchBrowsable*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TVirtualBranchBrowsable*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TMethodBrowsable_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TMethodBrowsable(void *p);
   static void deleteArray_TMethodBrowsable(void *p);
   static void destruct_TMethodBrowsable(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TMethodBrowsable*)
   {
      ::TMethodBrowsable *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TMethodBrowsable >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TMethodBrowsable", ::TMethodBrowsable::Class_Version(), "include/TBranchBrowsable.h", 103,
                  typeid(::TMethodBrowsable), DefineBehavior(ptr, ptr),
                  &::TMethodBrowsable::Dictionary, isa_proxy, 4,
                  sizeof(::TMethodBrowsable) );
      instance.SetDelete(&delete_TMethodBrowsable);
      instance.SetDeleteArray(&deleteArray_TMethodBrowsable);
      instance.SetDestructor(&destruct_TMethodBrowsable);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TMethodBrowsable*)
   {
      return GenerateInitInstanceLocal((::TMethodBrowsable*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TMethodBrowsable*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TNonSplitBrowsable_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TNonSplitBrowsable(void *p);
   static void deleteArray_TNonSplitBrowsable(void *p);
   static void destruct_TNonSplitBrowsable(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TNonSplitBrowsable*)
   {
      ::TNonSplitBrowsable *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TNonSplitBrowsable >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TNonSplitBrowsable", ::TNonSplitBrowsable::Class_Version(), "include/TBranchBrowsable.h", 128,
                  typeid(::TNonSplitBrowsable), DefineBehavior(ptr, ptr),
                  &::TNonSplitBrowsable::Dictionary, isa_proxy, 4,
                  sizeof(::TNonSplitBrowsable) );
      instance.SetDelete(&delete_TNonSplitBrowsable);
      instance.SetDeleteArray(&deleteArray_TNonSplitBrowsable);
      instance.SetDestructor(&destruct_TNonSplitBrowsable);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TNonSplitBrowsable*)
   {
      return GenerateInitInstanceLocal((::TNonSplitBrowsable*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TNonSplitBrowsable*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TCollectionPropertyBrowsable_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TCollectionPropertyBrowsable(void *p);
   static void deleteArray_TCollectionPropertyBrowsable(void *p);
   static void destruct_TCollectionPropertyBrowsable(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TCollectionPropertyBrowsable*)
   {
      ::TCollectionPropertyBrowsable *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TCollectionPropertyBrowsable >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TCollectionPropertyBrowsable", ::TCollectionPropertyBrowsable::Class_Version(), "include/TBranchBrowsable.h", 146,
                  typeid(::TCollectionPropertyBrowsable), DefineBehavior(ptr, ptr),
                  &::TCollectionPropertyBrowsable::Dictionary, isa_proxy, 4,
                  sizeof(::TCollectionPropertyBrowsable) );
      instance.SetDelete(&delete_TCollectionPropertyBrowsable);
      instance.SetDeleteArray(&deleteArray_TCollectionPropertyBrowsable);
      instance.SetDestructor(&destruct_TCollectionPropertyBrowsable);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TCollectionPropertyBrowsable*)
   {
      return GenerateInitInstanceLocal((::TCollectionPropertyBrowsable*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TCollectionPropertyBrowsable*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TCollectionMethodBrowsable_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TCollectionMethodBrowsable(void *p);
   static void deleteArray_TCollectionMethodBrowsable(void *p);
   static void destruct_TCollectionMethodBrowsable(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TCollectionMethodBrowsable*)
   {
      ::TCollectionMethodBrowsable *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TCollectionMethodBrowsable >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TCollectionMethodBrowsable", ::TCollectionMethodBrowsable::Class_Version(), "include/TBranchBrowsable.h", 173,
                  typeid(::TCollectionMethodBrowsable), DefineBehavior(ptr, ptr),
                  &::TCollectionMethodBrowsable::Dictionary, isa_proxy, 4,
                  sizeof(::TCollectionMethodBrowsable) );
      instance.SetDelete(&delete_TCollectionMethodBrowsable);
      instance.SetDeleteArray(&deleteArray_TCollectionMethodBrowsable);
      instance.SetDestructor(&destruct_TCollectionMethodBrowsable);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TCollectionMethodBrowsable*)
   {
      return GenerateInitInstanceLocal((::TCollectionMethodBrowsable*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TCollectionMethodBrowsable*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TLeaf_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TLeaf(void *p = 0);
   static void *newArray_TLeaf(Long_t size, void *p);
   static void delete_TLeaf(void *p);
   static void deleteArray_TLeaf(void *p);
   static void destruct_TLeaf(void *p);
   static void streamer_TLeaf(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TLeaf*)
   {
      ::TLeaf *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TLeaf >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TLeaf", ::TLeaf::Class_Version(), "include/TLeaf.h", 37,
                  typeid(::TLeaf), DefineBehavior(ptr, ptr),
                  &::TLeaf::Dictionary, isa_proxy, 1,
                  sizeof(::TLeaf) );
      instance.SetNew(&new_TLeaf);
      instance.SetNewArray(&newArray_TLeaf);
      instance.SetDelete(&delete_TLeaf);
      instance.SetDeleteArray(&deleteArray_TLeaf);
      instance.SetDestructor(&destruct_TLeaf);
      instance.SetStreamerFunc(&streamer_TLeaf);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TLeaf*)
   {
      return GenerateInitInstanceLocal((::TLeaf*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TLeaf*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TTreeCloner_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TTreeCloner(void *p);
   static void deleteArray_TTreeCloner(void *p);
   static void destruct_TTreeCloner(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TTreeCloner*)
   {
      ::TTreeCloner *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TTreeCloner >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TTreeCloner", ::TTreeCloner::Class_Version(), "include/TTreeCloner.h", 39,
                  typeid(::TTreeCloner), DefineBehavior(ptr, ptr),
                  &::TTreeCloner::Dictionary, isa_proxy, 4,
                  sizeof(::TTreeCloner) );
      instance.SetDelete(&delete_TTreeCloner);
      instance.SetDeleteArray(&deleteArray_TTreeCloner);
      instance.SetDestructor(&destruct_TTreeCloner);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TTreeCloner*)
   {
      return GenerateInitInstanceLocal((::TTreeCloner*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TTreeCloner*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TBranchClones_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TBranchClones(void *p = 0);
   static void *newArray_TBranchClones(Long_t size, void *p);
   static void delete_TBranchClones(void *p);
   static void deleteArray_TBranchClones(void *p);
   static void destruct_TBranchClones(void *p);
   static void streamer_TBranchClones(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TBranchClones*)
   {
      ::TBranchClones *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TBranchClones >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TBranchClones", ::TBranchClones::Class_Version(), "include/TBranchClones.h", 31,
                  typeid(::TBranchClones), DefineBehavior(ptr, ptr),
                  &::TBranchClones::Dictionary, isa_proxy, 1,
                  sizeof(::TBranchClones) );
      instance.SetNew(&new_TBranchClones);
      instance.SetNewArray(&newArray_TBranchClones);
      instance.SetDelete(&delete_TBranchClones);
      instance.SetDeleteArray(&deleteArray_TBranchClones);
      instance.SetDestructor(&destruct_TBranchClones);
      instance.SetStreamerFunc(&streamer_TBranchClones);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TBranchClones*)
   {
      return GenerateInitInstanceLocal((::TBranchClones*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TBranchClones*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TSelector_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TSelector(void *p = 0);
   static void *newArray_TSelector(Long_t size, void *p);
   static void delete_TSelector(void *p);
   static void deleteArray_TSelector(void *p);
   static void destruct_TSelector(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TSelector*)
   {
      ::TSelector *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TSelector >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TSelector", ::TSelector::Class_Version(), "include/TSelector.h", 39,
                  typeid(::TSelector), DefineBehavior(ptr, ptr),
                  &::TSelector::Dictionary, isa_proxy, 4,
                  sizeof(::TSelector) );
      instance.SetNew(&new_TSelector);
      instance.SetNewArray(&newArray_TSelector);
      instance.SetDelete(&delete_TSelector);
      instance.SetDeleteArray(&deleteArray_TSelector);
      instance.SetDestructor(&destruct_TSelector);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TSelector*)
   {
      return GenerateInitInstanceLocal((::TSelector*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TSelector*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TVirtualIndex_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TVirtualIndex(void *p);
   static void deleteArray_TVirtualIndex(void *p);
   static void destruct_TVirtualIndex(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TVirtualIndex*)
   {
      ::TVirtualIndex *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TVirtualIndex >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TVirtualIndex", ::TVirtualIndex::Class_Version(), "include/TVirtualIndex.h", 31,
                  typeid(::TVirtualIndex), DefineBehavior(ptr, ptr),
                  &::TVirtualIndex::Dictionary, isa_proxy, 4,
                  sizeof(::TVirtualIndex) );
      instance.SetDelete(&delete_TVirtualIndex);
      instance.SetDeleteArray(&deleteArray_TVirtualIndex);
      instance.SetDestructor(&destruct_TVirtualIndex);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TVirtualIndex*)
   {
      return GenerateInitInstanceLocal((::TVirtualIndex*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TVirtualIndex*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TVirtualTreePlayer_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TVirtualTreePlayer(void *p);
   static void deleteArray_TVirtualTreePlayer(void *p);
   static void destruct_TVirtualTreePlayer(void *p);
   static void streamer_TVirtualTreePlayer(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TVirtualTreePlayer*)
   {
      ::TVirtualTreePlayer *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TVirtualTreePlayer >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TVirtualTreePlayer", ::TVirtualTreePlayer::Class_Version(), "include/TVirtualTreePlayer.h", 38,
                  typeid(::TVirtualTreePlayer), DefineBehavior(ptr, ptr),
                  &::TVirtualTreePlayer::Dictionary, isa_proxy, 0,
                  sizeof(::TVirtualTreePlayer) );
      instance.SetDelete(&delete_TVirtualTreePlayer);
      instance.SetDeleteArray(&deleteArray_TVirtualTreePlayer);
      instance.SetDestructor(&destruct_TVirtualTreePlayer);
      instance.SetStreamerFunc(&streamer_TVirtualTreePlayer);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TVirtualTreePlayer*)
   {
      return GenerateInitInstanceLocal((::TVirtualTreePlayer*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TVirtualTreePlayer*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TEventList_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TEventList(void *p = 0);
   static void *newArray_TEventList(Long_t size, void *p);
   static void delete_TEventList(void *p);
   static void deleteArray_TEventList(void *p);
   static void destruct_TEventList(void *p);
   static void directoryAutoAdd_TEventList(void *p, TDirectory *dir);
   static void streamer_TEventList(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TEventList*)
   {
      ::TEventList *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TEventList >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TEventList", ::TEventList::Class_Version(), "include/TEventList.h", 33,
                  typeid(::TEventList), DefineBehavior(ptr, ptr),
                  &::TEventList::Dictionary, isa_proxy, 1,
                  sizeof(::TEventList) );
      instance.SetNew(&new_TEventList);
      instance.SetNewArray(&newArray_TEventList);
      instance.SetDelete(&delete_TEventList);
      instance.SetDeleteArray(&deleteArray_TEventList);
      instance.SetDestructor(&destruct_TEventList);
      instance.SetDirectoryAutoAdd(&directoryAutoAdd_TEventList);
      instance.SetStreamerFunc(&streamer_TEventList);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TEventList*)
   {
      return GenerateInitInstanceLocal((::TEventList*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TEventList*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TEntryList_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TEntryList(void *p = 0);
   static void *newArray_TEntryList(Long_t size, void *p);
   static void delete_TEntryList(void *p);
   static void deleteArray_TEntryList(void *p);
   static void destruct_TEntryList(void *p);
   static void directoryAutoAdd_TEntryList(void *p, TDirectory *dir);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TEntryList*)
   {
      ::TEntryList *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TEntryList >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TEntryList", ::TEntryList::Class_Version(), "include/TEntryList.h", 28,
                  typeid(::TEntryList), DefineBehavior(ptr, ptr),
                  &::TEntryList::Dictionary, isa_proxy, 4,
                  sizeof(::TEntryList) );
      instance.SetNew(&new_TEntryList);
      instance.SetNewArray(&newArray_TEntryList);
      instance.SetDelete(&delete_TEntryList);
      instance.SetDeleteArray(&deleteArray_TEntryList);
      instance.SetDestructor(&destruct_TEntryList);
      instance.SetDirectoryAutoAdd(&directoryAutoAdd_TEntryList);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TEntryList*)
   {
      return GenerateInitInstanceLocal((::TEntryList*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TEntryList*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TFriendElement_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TFriendElement(void *p = 0);
   static void *newArray_TFriendElement(Long_t size, void *p);
   static void delete_TFriendElement(void *p);
   static void deleteArray_TFriendElement(void *p);
   static void destruct_TFriendElement(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TFriendElement*)
   {
      ::TFriendElement *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TFriendElement >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TFriendElement", ::TFriendElement::Class_Version(), "include/TFriendElement.h", 35,
                  typeid(::TFriendElement), DefineBehavior(ptr, ptr),
                  &::TFriendElement::Dictionary, isa_proxy, 4,
                  sizeof(::TFriendElement) );
      instance.SetNew(&new_TFriendElement);
      instance.SetNewArray(&newArray_TFriendElement);
      instance.SetDelete(&delete_TFriendElement);
      instance.SetDeleteArray(&deleteArray_TFriendElement);
      instance.SetDestructor(&destruct_TFriendElement);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TFriendElement*)
   {
      return GenerateInitInstanceLocal((::TFriendElement*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TFriendElement*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TCut_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TCut(void *p = 0);
   static void *newArray_TCut(Long_t size, void *p);
   static void delete_TCut(void *p);
   static void deleteArray_TCut(void *p);
   static void destruct_TCut(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TCut*)
   {
      ::TCut *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TCut >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TCut", ::TCut::Class_Version(), "include/TCut.h", 27,
                  typeid(::TCut), DefineBehavior(ptr, ptr),
                  &::TCut::Dictionary, isa_proxy, 4,
                  sizeof(::TCut) );
      instance.SetNew(&new_TCut);
      instance.SetNewArray(&newArray_TCut);
      instance.SetDelete(&delete_TCut);
      instance.SetDeleteArray(&deleteArray_TCut);
      instance.SetDestructor(&destruct_TCut);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TCut*)
   {
      return GenerateInitInstanceLocal((::TCut*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TCut*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TBranchRef_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TBranchRef(void *p = 0);
   static void *newArray_TBranchRef(Long_t size, void *p);
   static void delete_TBranchRef(void *p);
   static void deleteArray_TBranchRef(void *p);
   static void destruct_TBranchRef(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TBranchRef*)
   {
      ::TBranchRef *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TBranchRef >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TBranchRef", ::TBranchRef::Class_Version(), "include/TBranchRef.h", 33,
                  typeid(::TBranchRef), DefineBehavior(ptr, ptr),
                  &::TBranchRef::Dictionary, isa_proxy, 4,
                  sizeof(::TBranchRef) );
      instance.SetNew(&new_TBranchRef);
      instance.SetNewArray(&newArray_TBranchRef);
      instance.SetDelete(&delete_TBranchRef);
      instance.SetDeleteArray(&deleteArray_TBranchRef);
      instance.SetDestructor(&destruct_TBranchRef);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TBranchRef*)
   {
      return GenerateInitInstanceLocal((::TBranchRef*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TBranchRef*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TTreeFriendLeafIter_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TTreeFriendLeafIter(void *p);
   static void deleteArray_TTreeFriendLeafIter(void *p);
   static void destruct_TTreeFriendLeafIter(void *p);
   static void streamer_TTreeFriendLeafIter(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TTreeFriendLeafIter*)
   {
      ::TTreeFriendLeafIter *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TTreeFriendLeafIter >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TTreeFriendLeafIter", ::TTreeFriendLeafIter::Class_Version(), "include/TTree.h", 484,
                  typeid(::TTreeFriendLeafIter), DefineBehavior(ptr, ptr),
                  &::TTreeFriendLeafIter::Dictionary, isa_proxy, 0,
                  sizeof(::TTreeFriendLeafIter) );
      instance.SetDelete(&delete_TTreeFriendLeafIter);
      instance.SetDeleteArray(&deleteArray_TTreeFriendLeafIter);
      instance.SetDestructor(&destruct_TTreeFriendLeafIter);
      instance.SetStreamerFunc(&streamer_TTreeFriendLeafIter);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TTreeFriendLeafIter*)
   {
      return GenerateInitInstanceLocal((::TTreeFriendLeafIter*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TTreeFriendLeafIter*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TBranchObject_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TBranchObject(void *p = 0);
   static void *newArray_TBranchObject(Long_t size, void *p);
   static void delete_TBranchObject(void *p);
   static void deleteArray_TBranchObject(void *p);
   static void destruct_TBranchObject(void *p);
   static void streamer_TBranchObject(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TBranchObject*)
   {
      ::TBranchObject *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TBranchObject >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TBranchObject", ::TBranchObject::Class_Version(), "include/TBranchObject.h", 28,
                  typeid(::TBranchObject), DefineBehavior(ptr, ptr),
                  &::TBranchObject::Dictionary, isa_proxy, 1,
                  sizeof(::TBranchObject) );
      instance.SetNew(&new_TBranchObject);
      instance.SetNewArray(&newArray_TBranchObject);
      instance.SetDelete(&delete_TBranchObject);
      instance.SetDeleteArray(&deleteArray_TBranchObject);
      instance.SetDestructor(&destruct_TBranchObject);
      instance.SetStreamerFunc(&streamer_TBranchObject);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TBranchObject*)
   {
      return GenerateInitInstanceLocal((::TBranchObject*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TBranchObject*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TIndArray_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void TIndArray_Dictionary();
   static void *new_TIndArray(void *p = 0);
   static void *newArray_TIndArray(Long_t size, void *p);
   static void delete_TIndArray(void *p);
   static void deleteArray_TIndArray(void *p);
   static void destruct_TIndArray(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TIndArray*)
   {
      // Make sure the shadow class has the right sizeof
      R__ASSERT(sizeof(::TIndArray) == sizeof(::ROOT::Shadow::TIndArray));
      ::TIndArray *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::TIndArray),0);
      static ::ROOT::TGenericClassInfo 
         instance("TIndArray", "include/TIndArray.h", 17,
                  typeid(::TIndArray), DefineBehavior(ptr, ptr),
                  &TIndArray_ShowMembers, &TIndArray_Dictionary, isa_proxy, 4,
                  sizeof(::TIndArray) );
      instance.SetNew(&new_TIndArray);
      instance.SetNewArray(&newArray_TIndArray);
      instance.SetDelete(&delete_TIndArray);
      instance.SetDeleteArray(&deleteArray_TIndArray);
      instance.SetDestructor(&destruct_TIndArray);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TIndArray*)
   {
      return GenerateInitInstanceLocal((::TIndArray*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TIndArray*)0x0); R__UseDummy(_R__UNIQUE_(Init));

   // Dictionary for non-ClassDef classes
   static void TIndArray_Dictionary() {
      ::ROOT::GenerateInitInstanceLocal((const ::TIndArray*)0x0)->GetClass();
   }

} // end of namespace ROOT

namespace ROOT {
   void TBranchSTL_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TBranchSTL(void *p = 0);
   static void *newArray_TBranchSTL(Long_t size, void *p);
   static void delete_TBranchSTL(void *p);
   static void deleteArray_TBranchSTL(void *p);
   static void destruct_TBranchSTL(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TBranchSTL*)
   {
      ::TBranchSTL *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TBranchSTL >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TBranchSTL", ::TBranchSTL::Class_Version(), "include/TBranchSTL.h", 22,
                  typeid(::TBranchSTL), DefineBehavior(ptr, ptr),
                  &::TBranchSTL::Dictionary, isa_proxy, 4,
                  sizeof(::TBranchSTL) );
      instance.SetNew(&new_TBranchSTL);
      instance.SetNewArray(&newArray_TBranchSTL);
      instance.SetDelete(&delete_TBranchSTL);
      instance.SetDeleteArray(&deleteArray_TBranchSTL);
      instance.SetDestructor(&destruct_TBranchSTL);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TBranchSTL*)
   {
      return GenerateInitInstanceLocal((::TBranchSTL*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TBranchSTL*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TChainElement_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TChainElement(void *p = 0);
   static void *newArray_TChainElement(Long_t size, void *p);
   static void delete_TChainElement(void *p);
   static void deleteArray_TChainElement(void *p);
   static void destruct_TChainElement(void *p);
   static void streamer_TChainElement(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TChainElement*)
   {
      ::TChainElement *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TChainElement >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TChainElement", ::TChainElement::Class_Version(), "include/TChainElement.h", 30,
                  typeid(::TChainElement), DefineBehavior(ptr, ptr),
                  &::TChainElement::Dictionary, isa_proxy, 0,
                  sizeof(::TChainElement) );
      instance.SetNew(&new_TChainElement);
      instance.SetNewArray(&newArray_TChainElement);
      instance.SetDelete(&delete_TChainElement);
      instance.SetDeleteArray(&deleteArray_TChainElement);
      instance.SetDestructor(&destruct_TChainElement);
      instance.SetStreamerFunc(&streamer_TChainElement);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TChainElement*)
   {
      return GenerateInitInstanceLocal((::TChainElement*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TChainElement*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TChain_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TChain(void *p = 0);
   static void *newArray_TChain(Long_t size, void *p);
   static void delete_TChain(void *p);
   static void deleteArray_TChain(void *p);
   static void destruct_TChain(void *p);
   static void directoryAutoAdd_TChain(void *p, TDirectory *dir);
   static void streamer_TChain(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TChain*)
   {
      ::TChain *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TChain >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TChain", ::TChain::Class_Version(), "include/TChain.h", 35,
                  typeid(::TChain), DefineBehavior(ptr, ptr),
                  &::TChain::Dictionary, isa_proxy, 1,
                  sizeof(::TChain) );
      instance.SetNew(&new_TChain);
      instance.SetNewArray(&newArray_TChain);
      instance.SetDelete(&delete_TChain);
      instance.SetDeleteArray(&deleteArray_TChain);
      instance.SetDestructor(&destruct_TChain);
      instance.SetDirectoryAutoAdd(&directoryAutoAdd_TChain);
      instance.SetStreamerFunc(&streamer_TChain);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TChain*)
   {
      return GenerateInitInstanceLocal((::TChain*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TChain*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TEntryListBlock_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TEntryListBlock(void *p = 0);
   static void *newArray_TEntryListBlock(Long_t size, void *p);
   static void delete_TEntryListBlock(void *p);
   static void deleteArray_TEntryListBlock(void *p);
   static void destruct_TEntryListBlock(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TEntryListBlock*)
   {
      ::TEntryListBlock *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TEntryListBlock >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TEntryListBlock", ::TEntryListBlock::Class_Version(), "include/TEntryListBlock.h", 46,
                  typeid(::TEntryListBlock), DefineBehavior(ptr, ptr),
                  &::TEntryListBlock::Dictionary, isa_proxy, 4,
                  sizeof(::TEntryListBlock) );
      instance.SetNew(&new_TEntryListBlock);
      instance.SetNewArray(&newArray_TEntryListBlock);
      instance.SetDelete(&delete_TEntryListBlock);
      instance.SetDeleteArray(&deleteArray_TEntryListBlock);
      instance.SetDestructor(&destruct_TEntryListBlock);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TEntryListBlock*)
   {
      return GenerateInitInstanceLocal((::TEntryListBlock*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TEntryListBlock*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TEntryListFromFile_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TEntryListFromFile(void *p = 0);
   static void *newArray_TEntryListFromFile(Long_t size, void *p);
   static void delete_TEntryListFromFile(void *p);
   static void deleteArray_TEntryListFromFile(void *p);
   static void destruct_TEntryListFromFile(void *p);
   static void directoryAutoAdd_TEntryListFromFile(void *p, TDirectory *dir);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TEntryListFromFile*)
   {
      ::TEntryListFromFile *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TEntryListFromFile >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TEntryListFromFile", ::TEntryListFromFile::Class_Version(), "include/TEntryListFromFile.h", 41,
                  typeid(::TEntryListFromFile), DefineBehavior(ptr, ptr),
                  &::TEntryListFromFile::Dictionary, isa_proxy, 4,
                  sizeof(::TEntryListFromFile) );
      instance.SetNew(&new_TEntryListFromFile);
      instance.SetNewArray(&newArray_TEntryListFromFile);
      instance.SetDelete(&delete_TEntryListFromFile);
      instance.SetDeleteArray(&deleteArray_TEntryListFromFile);
      instance.SetDestructor(&destruct_TEntryListFromFile);
      instance.SetDirectoryAutoAdd(&directoryAutoAdd_TEntryListFromFile);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TEntryListFromFile*)
   {
      return GenerateInitInstanceLocal((::TEntryListFromFile*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TEntryListFromFile*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TLeafB_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TLeafB(void *p = 0);
   static void *newArray_TLeafB(Long_t size, void *p);
   static void delete_TLeafB(void *p);
   static void deleteArray_TLeafB(void *p);
   static void destruct_TLeafB(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TLeafB*)
   {
      ::TLeafB *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TLeafB >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TLeafB", ::TLeafB::Class_Version(), "include/TLeafB.h", 28,
                  typeid(::TLeafB), DefineBehavior(ptr, ptr),
                  &::TLeafB::Dictionary, isa_proxy, 4,
                  sizeof(::TLeafB) );
      instance.SetNew(&new_TLeafB);
      instance.SetNewArray(&newArray_TLeafB);
      instance.SetDelete(&delete_TLeafB);
      instance.SetDeleteArray(&deleteArray_TLeafB);
      instance.SetDestructor(&destruct_TLeafB);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TLeafB*)
   {
      return GenerateInitInstanceLocal((::TLeafB*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TLeafB*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TLeafC_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TLeafC(void *p = 0);
   static void *newArray_TLeafC(Long_t size, void *p);
   static void delete_TLeafC(void *p);
   static void deleteArray_TLeafC(void *p);
   static void destruct_TLeafC(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TLeafC*)
   {
      ::TLeafC *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TLeafC >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TLeafC", ::TLeafC::Class_Version(), "include/TLeafC.h", 28,
                  typeid(::TLeafC), DefineBehavior(ptr, ptr),
                  &::TLeafC::Dictionary, isa_proxy, 4,
                  sizeof(::TLeafC) );
      instance.SetNew(&new_TLeafC);
      instance.SetNewArray(&newArray_TLeafC);
      instance.SetDelete(&delete_TLeafC);
      instance.SetDeleteArray(&deleteArray_TLeafC);
      instance.SetDestructor(&destruct_TLeafC);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TLeafC*)
   {
      return GenerateInitInstanceLocal((::TLeafC*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TLeafC*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TLeafD_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TLeafD(void *p = 0);
   static void *newArray_TLeafD(Long_t size, void *p);
   static void delete_TLeafD(void *p);
   static void deleteArray_TLeafD(void *p);
   static void destruct_TLeafD(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TLeafD*)
   {
      ::TLeafD *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TLeafD >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TLeafD", ::TLeafD::Class_Version(), "include/TLeafD.h", 28,
                  typeid(::TLeafD), DefineBehavior(ptr, ptr),
                  &::TLeafD::Dictionary, isa_proxy, 4,
                  sizeof(::TLeafD) );
      instance.SetNew(&new_TLeafD);
      instance.SetNewArray(&newArray_TLeafD);
      instance.SetDelete(&delete_TLeafD);
      instance.SetDeleteArray(&deleteArray_TLeafD);
      instance.SetDestructor(&destruct_TLeafD);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TLeafD*)
   {
      return GenerateInitInstanceLocal((::TLeafD*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TLeafD*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TLeafElement_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TLeafElement(void *p = 0);
   static void *newArray_TLeafElement(Long_t size, void *p);
   static void delete_TLeafElement(void *p);
   static void deleteArray_TLeafElement(void *p);
   static void destruct_TLeafElement(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TLeafElement*)
   {
      ::TLeafElement *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TLeafElement >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TLeafElement", ::TLeafElement::Class_Version(), "include/TLeafElement.h", 34,
                  typeid(::TLeafElement), DefineBehavior(ptr, ptr),
                  &::TLeafElement::Dictionary, isa_proxy, 4,
                  sizeof(::TLeafElement) );
      instance.SetNew(&new_TLeafElement);
      instance.SetNewArray(&newArray_TLeafElement);
      instance.SetDelete(&delete_TLeafElement);
      instance.SetDeleteArray(&deleteArray_TLeafElement);
      instance.SetDestructor(&destruct_TLeafElement);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TLeafElement*)
   {
      return GenerateInitInstanceLocal((::TLeafElement*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TLeafElement*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TLeafF_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TLeafF(void *p = 0);
   static void *newArray_TLeafF(Long_t size, void *p);
   static void delete_TLeafF(void *p);
   static void deleteArray_TLeafF(void *p);
   static void destruct_TLeafF(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TLeafF*)
   {
      ::TLeafF *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TLeafF >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TLeafF", ::TLeafF::Class_Version(), "include/TLeafF.h", 28,
                  typeid(::TLeafF), DefineBehavior(ptr, ptr),
                  &::TLeafF::Dictionary, isa_proxy, 4,
                  sizeof(::TLeafF) );
      instance.SetNew(&new_TLeafF);
      instance.SetNewArray(&newArray_TLeafF);
      instance.SetDelete(&delete_TLeafF);
      instance.SetDeleteArray(&deleteArray_TLeafF);
      instance.SetDestructor(&destruct_TLeafF);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TLeafF*)
   {
      return GenerateInitInstanceLocal((::TLeafF*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TLeafF*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TLeafI_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TLeafI(void *p = 0);
   static void *newArray_TLeafI(Long_t size, void *p);
   static void delete_TLeafI(void *p);
   static void deleteArray_TLeafI(void *p);
   static void destruct_TLeafI(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TLeafI*)
   {
      ::TLeafI *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TLeafI >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TLeafI", ::TLeafI::Class_Version(), "include/TLeafI.h", 29,
                  typeid(::TLeafI), DefineBehavior(ptr, ptr),
                  &::TLeafI::Dictionary, isa_proxy, 4,
                  sizeof(::TLeafI) );
      instance.SetNew(&new_TLeafI);
      instance.SetNewArray(&newArray_TLeafI);
      instance.SetDelete(&delete_TLeafI);
      instance.SetDeleteArray(&deleteArray_TLeafI);
      instance.SetDestructor(&destruct_TLeafI);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TLeafI*)
   {
      return GenerateInitInstanceLocal((::TLeafI*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TLeafI*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TLeafL_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TLeafL(void *p = 0);
   static void *newArray_TLeafL(Long_t size, void *p);
   static void delete_TLeafL(void *p);
   static void deleteArray_TLeafL(void *p);
   static void destruct_TLeafL(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TLeafL*)
   {
      ::TLeafL *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TLeafL >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TLeafL", ::TLeafL::Class_Version(), "include/TLeafL.h", 29,
                  typeid(::TLeafL), DefineBehavior(ptr, ptr),
                  &::TLeafL::Dictionary, isa_proxy, 4,
                  sizeof(::TLeafL) );
      instance.SetNew(&new_TLeafL);
      instance.SetNewArray(&newArray_TLeafL);
      instance.SetDelete(&delete_TLeafL);
      instance.SetDeleteArray(&deleteArray_TLeafL);
      instance.SetDestructor(&destruct_TLeafL);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TLeafL*)
   {
      return GenerateInitInstanceLocal((::TLeafL*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TLeafL*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TLeafObject_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TLeafObject(void *p = 0);
   static void *newArray_TLeafObject(Long_t size, void *p);
   static void delete_TLeafObject(void *p);
   static void deleteArray_TLeafObject(void *p);
   static void destruct_TLeafObject(void *p);
   static void streamer_TLeafObject(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TLeafObject*)
   {
      ::TLeafObject *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TLeafObject >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TLeafObject", ::TLeafObject::Class_Version(), "include/TLeafObject.h", 35,
                  typeid(::TLeafObject), DefineBehavior(ptr, ptr),
                  &::TLeafObject::Dictionary, isa_proxy, 1,
                  sizeof(::TLeafObject) );
      instance.SetNew(&new_TLeafObject);
      instance.SetNewArray(&newArray_TLeafObject);
      instance.SetDelete(&delete_TLeafObject);
      instance.SetDeleteArray(&deleteArray_TLeafObject);
      instance.SetDestructor(&destruct_TLeafObject);
      instance.SetStreamerFunc(&streamer_TLeafObject);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TLeafObject*)
   {
      return GenerateInitInstanceLocal((::TLeafObject*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TLeafObject*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TLeafO_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TLeafO(void *p = 0);
   static void *newArray_TLeafO(Long_t size, void *p);
   static void delete_TLeafO(void *p);
   static void deleteArray_TLeafO(void *p);
   static void destruct_TLeafO(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TLeafO*)
   {
      ::TLeafO *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TLeafO >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TLeafO", ::TLeafO::Class_Version(), "include/TLeafO.h", 28,
                  typeid(::TLeafO), DefineBehavior(ptr, ptr),
                  &::TLeafO::Dictionary, isa_proxy, 4,
                  sizeof(::TLeafO) );
      instance.SetNew(&new_TLeafO);
      instance.SetNewArray(&newArray_TLeafO);
      instance.SetDelete(&delete_TLeafO);
      instance.SetDeleteArray(&deleteArray_TLeafO);
      instance.SetDestructor(&destruct_TLeafO);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TLeafO*)
   {
      return GenerateInitInstanceLocal((::TLeafO*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TLeafO*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TLeafS_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TLeafS(void *p = 0);
   static void *newArray_TLeafS(Long_t size, void *p);
   static void delete_TLeafS(void *p);
   static void deleteArray_TLeafS(void *p);
   static void destruct_TLeafS(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TLeafS*)
   {
      ::TLeafS *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TLeafS >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TLeafS", ::TLeafS::Class_Version(), "include/TLeafS.h", 28,
                  typeid(::TLeafS), DefineBehavior(ptr, ptr),
                  &::TLeafS::Dictionary, isa_proxy, 4,
                  sizeof(::TLeafS) );
      instance.SetNew(&new_TLeafS);
      instance.SetNewArray(&newArray_TLeafS);
      instance.SetDelete(&delete_TLeafS);
      instance.SetDeleteArray(&deleteArray_TLeafS);
      instance.SetDestructor(&destruct_TLeafS);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TLeafS*)
   {
      return GenerateInitInstanceLocal((::TLeafS*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TLeafS*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TNtupleD_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TNtupleD(void *p = 0);
   static void *newArray_TNtupleD(Long_t size, void *p);
   static void delete_TNtupleD(void *p);
   static void deleteArray_TNtupleD(void *p);
   static void destruct_TNtupleD(void *p);
   static void directoryAutoAdd_TNtupleD(void *p, TDirectory *dir);
   static void streamer_TNtupleD(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TNtupleD*)
   {
      ::TNtupleD *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TNtupleD >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TNtupleD", ::TNtupleD::Class_Version(), "include/TNtupleD.h", 30,
                  typeid(::TNtupleD), DefineBehavior(ptr, ptr),
                  &::TNtupleD::Dictionary, isa_proxy, 1,
                  sizeof(::TNtupleD) );
      instance.SetNew(&new_TNtupleD);
      instance.SetNewArray(&newArray_TNtupleD);
      instance.SetDelete(&delete_TNtupleD);
      instance.SetDeleteArray(&deleteArray_TNtupleD);
      instance.SetDestructor(&destruct_TNtupleD);
      instance.SetDirectoryAutoAdd(&directoryAutoAdd_TNtupleD);
      instance.SetStreamerFunc(&streamer_TNtupleD);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TNtupleD*)
   {
      return GenerateInitInstanceLocal((::TNtupleD*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TNtupleD*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TNtuple_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TNtuple(void *p = 0);
   static void *newArray_TNtuple(Long_t size, void *p);
   static void delete_TNtuple(void *p);
   static void deleteArray_TNtuple(void *p);
   static void destruct_TNtuple(void *p);
   static void directoryAutoAdd_TNtuple(void *p, TDirectory *dir);
   static void streamer_TNtuple(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TNtuple*)
   {
      ::TNtuple *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TNtuple >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TNtuple", ::TNtuple::Class_Version(), "include/TNtuple.h", 30,
                  typeid(::TNtuple), DefineBehavior(ptr, ptr),
                  &::TNtuple::Dictionary, isa_proxy, 1,
                  sizeof(::TNtuple) );
      instance.SetNew(&new_TNtuple);
      instance.SetNewArray(&newArray_TNtuple);
      instance.SetDelete(&delete_TNtuple);
      instance.SetDeleteArray(&deleteArray_TNtuple);
      instance.SetDestructor(&destruct_TNtuple);
      instance.SetDirectoryAutoAdd(&directoryAutoAdd_TNtuple);
      instance.SetStreamerFunc(&streamer_TNtuple);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TNtuple*)
   {
      return GenerateInitInstanceLocal((::TNtuple*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TNtuple*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TQueryResult_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TQueryResult(void *p = 0);
   static void *newArray_TQueryResult(Long_t size, void *p);
   static void delete_TQueryResult(void *p);
   static void deleteArray_TQueryResult(void *p);
   static void destruct_TQueryResult(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TQueryResult*)
   {
      ::TQueryResult *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TQueryResult >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TQueryResult", ::TQueryResult::Class_Version(), "include/TQueryResult.h", 44,
                  typeid(::TQueryResult), DefineBehavior(ptr, ptr),
                  &::TQueryResult::Dictionary, isa_proxy, 4,
                  sizeof(::TQueryResult) );
      instance.SetNew(&new_TQueryResult);
      instance.SetNewArray(&newArray_TQueryResult);
      instance.SetDelete(&delete_TQueryResult);
      instance.SetDeleteArray(&deleteArray_TQueryResult);
      instance.SetDestructor(&destruct_TQueryResult);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TQueryResult*)
   {
      return GenerateInitInstanceLocal((::TQueryResult*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TQueryResult*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TSelectorList_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TSelectorList(void *p = 0);
   static void *newArray_TSelectorList(Long_t size, void *p);
   static void delete_TSelectorList(void *p);
   static void deleteArray_TSelectorList(void *p);
   static void destruct_TSelectorList(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TSelectorList*)
   {
      ::TSelectorList *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TSelectorList >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TSelectorList", ::TSelectorList::Class_Version(), "include/TSelectorList.h", 33,
                  typeid(::TSelectorList), DefineBehavior(ptr, ptr),
                  &::TSelectorList::Dictionary, isa_proxy, 4,
                  sizeof(::TSelectorList) );
      instance.SetNew(&new_TSelectorList);
      instance.SetNewArray(&newArray_TSelectorList);
      instance.SetDelete(&delete_TSelectorList);
      instance.SetDeleteArray(&deleteArray_TSelectorList);
      instance.SetDestructor(&destruct_TSelectorList);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TSelectorList*)
   {
      return GenerateInitInstanceLocal((::TSelectorList*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TSelectorList*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TSelectorCint_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TSelectorCint(void *p = 0);
   static void *newArray_TSelectorCint(Long_t size, void *p);
   static void delete_TSelectorCint(void *p);
   static void deleteArray_TSelectorCint(void *p);
   static void destruct_TSelectorCint(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TSelectorCint*)
   {
      ::TSelectorCint *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TSelectorCint >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TSelectorCint", ::TSelectorCint::Class_Version(), "include/TSelectorCint.h", 32,
                  typeid(::TSelectorCint), DefineBehavior(ptr, ptr),
                  &::TSelectorCint::Dictionary, isa_proxy, 4,
                  sizeof(::TSelectorCint) );
      instance.SetNew(&new_TSelectorCint);
      instance.SetNewArray(&newArray_TSelectorCint);
      instance.SetDelete(&delete_TSelectorCint);
      instance.SetDeleteArray(&deleteArray_TSelectorCint);
      instance.SetDestructor(&destruct_TSelectorCint);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TSelectorCint*)
   {
      return GenerateInitInstanceLocal((::TSelectorCint*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TSelectorCint*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TSelectorScalar_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TSelectorScalar(void *p = 0);
   static void *newArray_TSelectorScalar(Long_t size, void *p);
   static void delete_TSelectorScalar(void *p);
   static void deleteArray_TSelectorScalar(void *p);
   static void destruct_TSelectorScalar(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TSelectorScalar*)
   {
      ::TSelectorScalar *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TSelectorScalar >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TSelectorScalar", ::TSelectorScalar::Class_Version(), "include/TSelectorScalar.h", 39,
                  typeid(::TSelectorScalar), DefineBehavior(ptr, ptr),
                  &::TSelectorScalar::Dictionary, isa_proxy, 4,
                  sizeof(::TSelectorScalar) );
      instance.SetNew(&new_TSelectorScalar);
      instance.SetNewArray(&newArray_TSelectorScalar);
      instance.SetDelete(&delete_TSelectorScalar);
      instance.SetDeleteArray(&deleteArray_TSelectorScalar);
      instance.SetDestructor(&destruct_TSelectorScalar);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TSelectorScalar*)
   {
      return GenerateInitInstanceLocal((::TSelectorScalar*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TSelectorScalar*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TTreeCache_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TTreeCache(void *p = 0);
   static void *newArray_TTreeCache(Long_t size, void *p);
   static void delete_TTreeCache(void *p);
   static void deleteArray_TTreeCache(void *p);
   static void destruct_TTreeCache(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TTreeCache*)
   {
      ::TTreeCache *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TTreeCache >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TTreeCache", ::TTreeCache::Class_Version(), "include/TTreeCache.h", 34,
                  typeid(::TTreeCache), DefineBehavior(ptr, ptr),
                  &::TTreeCache::Dictionary, isa_proxy, 4,
                  sizeof(::TTreeCache) );
      instance.SetNew(&new_TTreeCache);
      instance.SetNewArray(&newArray_TTreeCache);
      instance.SetDelete(&delete_TTreeCache);
      instance.SetDeleteArray(&deleteArray_TTreeCache);
      instance.SetDestructor(&destruct_TTreeCache);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TTreeCache*)
   {
      return GenerateInitInstanceLocal((::TTreeCache*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TTreeCache*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TTreeCacheUnzip_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TTreeCacheUnzip(void *p = 0);
   static void *newArray_TTreeCacheUnzip(Long_t size, void *p);
   static void delete_TTreeCacheUnzip(void *p);
   static void deleteArray_TTreeCacheUnzip(void *p);
   static void destruct_TTreeCacheUnzip(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TTreeCacheUnzip*)
   {
      ::TTreeCacheUnzip *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TTreeCacheUnzip >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TTreeCacheUnzip", ::TTreeCacheUnzip::Class_Version(), "include/TTreeCacheUnzip.h", 41,
                  typeid(::TTreeCacheUnzip), DefineBehavior(ptr, ptr),
                  &::TTreeCacheUnzip::Dictionary, isa_proxy, 4,
                  sizeof(::TTreeCacheUnzip) );
      instance.SetNew(&new_TTreeCacheUnzip);
      instance.SetNewArray(&newArray_TTreeCacheUnzip);
      instance.SetDelete(&delete_TTreeCacheUnzip);
      instance.SetDeleteArray(&deleteArray_TTreeCacheUnzip);
      instance.SetDestructor(&destruct_TTreeCacheUnzip);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TTreeCacheUnzip*)
   {
      return GenerateInitInstanceLocal((::TTreeCacheUnzip*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TTreeCacheUnzip*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TTreeResult_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TTreeResult(void *p = 0);
   static void *newArray_TTreeResult(Long_t size, void *p);
   static void delete_TTreeResult(void *p);
   static void deleteArray_TTreeResult(void *p);
   static void destruct_TTreeResult(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TTreeResult*)
   {
      ::TTreeResult *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TTreeResult >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TTreeResult", ::TTreeResult::Class_Version(), "include/TTreeResult.h", 36,
                  typeid(::TTreeResult), DefineBehavior(ptr, ptr),
                  &::TTreeResult::Dictionary, isa_proxy, 4,
                  sizeof(::TTreeResult) );
      instance.SetNew(&new_TTreeResult);
      instance.SetNewArray(&newArray_TTreeResult);
      instance.SetDelete(&delete_TTreeResult);
      instance.SetDeleteArray(&deleteArray_TTreeResult);
      instance.SetDestructor(&destruct_TTreeResult);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TTreeResult*)
   {
      return GenerateInitInstanceLocal((::TTreeResult*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TTreeResult*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TTreeRow_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TTreeRow(void *p = 0);
   static void *newArray_TTreeRow(Long_t size, void *p);
   static void delete_TTreeRow(void *p);
   static void deleteArray_TTreeRow(void *p);
   static void destruct_TTreeRow(void *p);
   static void streamer_TTreeRow(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TTreeRow*)
   {
      ::TTreeRow *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TTreeRow >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TTreeRow", ::TTreeRow::Class_Version(), "include/TTreeRow.h", 31,
                  typeid(::TTreeRow), DefineBehavior(ptr, ptr),
                  &::TTreeRow::Dictionary, isa_proxy, 1,
                  sizeof(::TTreeRow) );
      instance.SetNew(&new_TTreeRow);
      instance.SetNewArray(&newArray_TTreeRow);
      instance.SetDelete(&delete_TTreeRow);
      instance.SetDeleteArray(&deleteArray_TTreeRow);
      instance.SetDestructor(&destruct_TTreeRow);
      instance.SetStreamerFunc(&streamer_TTreeRow);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TTreeRow*)
   {
      return GenerateInitInstanceLocal((::TTreeRow*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TTreeRow*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TTreeSQL_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TTreeSQL(void *p);
   static void deleteArray_TTreeSQL(void *p);
   static void destruct_TTreeSQL(void *p);
   static void directoryAutoAdd_TTreeSQL(void *p, TDirectory *dir);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TTreeSQL*)
   {
      ::TTreeSQL *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TTreeSQL >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TTreeSQL", ::TTreeSQL::Class_Version(), "include/TTreeSQL.h", 43,
                  typeid(::TTreeSQL), DefineBehavior(ptr, ptr),
                  &::TTreeSQL::Dictionary, isa_proxy, 4,
                  sizeof(::TTreeSQL) );
      instance.SetDelete(&delete_TTreeSQL);
      instance.SetDeleteArray(&deleteArray_TTreeSQL);
      instance.SetDestructor(&destruct_TTreeSQL);
      instance.SetDirectoryAutoAdd(&directoryAutoAdd_TTreeSQL);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TTreeSQL*)
   {
      return GenerateInitInstanceLocal((::TTreeSQL*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TTreeSQL*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

//______________________________________________________________________________
void TBasket::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TBasket.
      TClass *R__cl = ::TBasket::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fBufferSize", &fBufferSize);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNevBufSize", &fNevBufSize);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNevBuf", &fNevBuf);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fLast", &fLast);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fHeaderOnly", &fHeaderOnly);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fDisplacement", &fDisplacement);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fEntryOffset", &fEntryOffset);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fBranch", &fBranch);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fCompressedSize", &fCompressedSize);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fCompressedBuffer", &fCompressedBuffer);
      TKey::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TBasket(void *p) {
      return  p ? new(p) ::TBasket : new ::TBasket;
   }
   static void *newArray_TBasket(Long_t nElements, void *p) {
      return p ? new(p) ::TBasket[nElements] : new ::TBasket[nElements];
   }
   // Wrapper around operator delete
   static void delete_TBasket(void *p) {
      delete ((::TBasket*)p);
   }
   static void deleteArray_TBasket(void *p) {
      delete [] ((::TBasket*)p);
   }
   static void destruct_TBasket(void *p) {
      typedef ::TBasket current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TBasket(TBuffer &buf, void *obj) {
      ((::TBasket*)obj)->::TBasket::Streamer(buf);
   }
} // end of namespace ROOT for class ::TBasket

//______________________________________________________________________________
void TBranch::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TBranch.
      TClass *R__cl = ::TBranch::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fCompress", &fCompress);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fBasketSize", &fBasketSize);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fEntryOffsetLen", &fEntryOffsetLen);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fWriteBasket", &fWriteBasket);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fEntryNumber", &fEntryNumber);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fOffset", &fOffset);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMaxBaskets", &fMaxBaskets);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNBaskets", &fNBaskets);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fSplitLevel", &fSplitLevel);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNleaves", &fNleaves);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fReadBasket", &fReadBasket);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fReadEntry", &fReadEntry);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fEntries", &fEntries);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fFirstEntry", &fFirstEntry);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTotBytes", &fTotBytes);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fZipBytes", &fZipBytes);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fBranches", &fBranches);
      R__insp.InspectMember(fBranches, "fBranches.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fLeaves", &fLeaves);
      R__insp.InspectMember(fLeaves, "fLeaves.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fBaskets", &fBaskets);
      R__insp.InspectMember(fBaskets, "fBaskets.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fBasketBytes", &fBasketBytes);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fBasketEntry", &fBasketEntry);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fBasketSeek", &fBasketSeek);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fTree", &fTree);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fMother", &fMother);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fParent", &fParent);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fAddress", &fAddress);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fDirectory", &fDirectory);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fFileName", &fFileName);
      R__insp.InspectMember(fFileName, "fFileName.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fEntryBuffer", &fEntryBuffer);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fBrowsables", &fBrowsables);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fSkipZip", &fSkipZip);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fReadLeaves", &fReadLeaves);
      TNamed::ShowMembers(R__insp);
      TAttFill::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TBranch(void *p) {
      return  p ? new(p) ::TBranch : new ::TBranch;
   }
   static void *newArray_TBranch(Long_t nElements, void *p) {
      return p ? new(p) ::TBranch[nElements] : new ::TBranch[nElements];
   }
   // Wrapper around operator delete
   static void delete_TBranch(void *p) {
      delete ((::TBranch*)p);
   }
   static void deleteArray_TBranch(void *p) {
      delete [] ((::TBranch*)p);
   }
   static void destruct_TBranch(void *p) {
      typedef ::TBranch current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TBranch(TBuffer &buf, void *obj) {
      ((::TBranch*)obj)->::TBranch::Streamer(buf);
   }
} // end of namespace ROOT for class ::TBranch

//______________________________________________________________________________
void TBranchClones::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TBranchClones.
      TClass *R__cl = ::TBranchClones::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fList", &fList);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fRead", &fRead);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fN", &fN);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNdataMax", &fNdataMax);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fClassName", &fClassName);
      R__insp.InspectMember(fClassName, "fClassName.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fBranchCount", &fBranchCount);
      TBranch::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TBranchClones(void *p) {
      return  p ? new(p) ::TBranchClones : new ::TBranchClones;
   }
   static void *newArray_TBranchClones(Long_t nElements, void *p) {
      return p ? new(p) ::TBranchClones[nElements] : new ::TBranchClones[nElements];
   }
   // Wrapper around operator delete
   static void delete_TBranchClones(void *p) {
      delete ((::TBranchClones*)p);
   }
   static void deleteArray_TBranchClones(void *p) {
      delete [] ((::TBranchClones*)p);
   }
   static void destruct_TBranchClones(void *p) {
      typedef ::TBranchClones current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TBranchClones(TBuffer &buf, void *obj) {
      ((::TBranchClones*)obj)->::TBranchClones::Streamer(buf);
   }
} // end of namespace ROOT for class ::TBranchClones

//______________________________________________________________________________
void TBranchElement::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TBranchElement.
      TClass *R__cl = ::TBranchElement::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fClassName", &fClassName);
      R__insp.InspectMember(fClassName, "fClassName.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fParentName", &fParentName);
      R__insp.InspectMember(fParentName, "fParentName.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fClonesName", &fClonesName);
      R__insp.InspectMember(fClonesName, "fClonesName.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fCollProxy", &fCollProxy);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fCheckSum", &fCheckSum);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fClassVersion", &fClassVersion);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fID", &fID);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fType", &fType);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fStreamerType", &fStreamerType);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMaximum", &fMaximum);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fSTLtype", &fSTLtype);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNdata", &fNdata);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fBranchCount", &fBranchCount);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fBranchCount2", &fBranchCount2);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fInfo", &fInfo);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fObject", &fObject);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fOnfileObject", &fOnfileObject);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fInit", &fInit);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fInitOffsets", &fInitOffsets);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTargetClass", (void*)&fTargetClass);
      R__insp.InspectMember("TClassRef", (void*)&fTargetClass, "fTargetClass.", true);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fCurrentClass", (void*)&fCurrentClass);
      R__insp.InspectMember("TClassRef", (void*)&fCurrentClass, "fCurrentClass.", true);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fParentClass", (void*)&fParentClass);
      R__insp.InspectMember("TClassRef", (void*)&fParentClass, "fParentClass.", true);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fBranchClass", (void*)&fBranchClass);
      R__insp.InspectMember("TClassRef", (void*)&fBranchClass, "fBranchClass.", true);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fBranchOffset", &fBranchOffset);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fBranchID", &fBranchID);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fIDs", (void*)&fIDs);
      R__insp.InspectMember("vector<Int_t>", (void*)&fIDs, "fIDs.", true);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fReadActionSequence", &fReadActionSequence);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fIterators", &fIterators);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fPtrIterators", &fPtrIterators);
      TBranch::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TBranchElement(void *p) {
      return  p ? new(p) ::TBranchElement : new ::TBranchElement;
   }
   static void *newArray_TBranchElement(Long_t nElements, void *p) {
      return p ? new(p) ::TBranchElement[nElements] : new ::TBranchElement[nElements];
   }
   // Wrapper around operator delete
   static void delete_TBranchElement(void *p) {
      delete ((::TBranchElement*)p);
   }
   static void deleteArray_TBranchElement(void *p) {
      delete [] ((::TBranchElement*)p);
   }
   static void destruct_TBranchElement(void *p) {
      typedef ::TBranchElement current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TBranchElement(TBuffer &buf, void *obj) {
      ((::TBranchElement*)obj)->::TBranchElement::Streamer(buf);
   }
} // end of namespace ROOT for class ::TBranchElement

//______________________________________________________________________________
void TBranchObject::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TBranchObject.
      TClass *R__cl = ::TBranchObject::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fClassName", &fClassName);
      R__insp.InspectMember(fClassName, "fClassName.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fOldObject", &fOldObject);
      TBranch::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TBranchObject(void *p) {
      return  p ? new(p) ::TBranchObject : new ::TBranchObject;
   }
   static void *newArray_TBranchObject(Long_t nElements, void *p) {
      return p ? new(p) ::TBranchObject[nElements] : new ::TBranchObject[nElements];
   }
   // Wrapper around operator delete
   static void delete_TBranchObject(void *p) {
      delete ((::TBranchObject*)p);
   }
   static void deleteArray_TBranchObject(void *p) {
      delete [] ((::TBranchObject*)p);
   }
   static void destruct_TBranchObject(void *p) {
      typedef ::TBranchObject current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TBranchObject(TBuffer &buf, void *obj) {
      ((::TBranchObject*)obj)->::TBranchObject::Streamer(buf);
   }
} // end of namespace ROOT for class ::TBranchObject

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

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

//______________________________________________________________________________
void TBranchRef::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TBranchRef.
      TClass *R__cl = ::TBranchRef::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fRefTable", &fRefTable);
      TBranch::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TBranchRef(void *p) {
      return  p ? new(p) ::TBranchRef : new ::TBranchRef;
   }
   static void *newArray_TBranchRef(Long_t nElements, void *p) {
      return p ? new(p) ::TBranchRef[nElements] : new ::TBranchRef[nElements];
   }
   // Wrapper around operator delete
   static void delete_TBranchRef(void *p) {
      delete ((::TBranchRef*)p);
   }
   static void deleteArray_TBranchRef(void *p) {
      delete [] ((::TBranchRef*)p);
   }
   static void destruct_TBranchRef(void *p) {
      typedef ::TBranchRef current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TBranchRef

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

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

//______________________________________________________________________________
void TTreeSQL::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TTreeSQL.
      TClass *R__cl = ::TTreeSQL::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fCurrentEntry", &fCurrentEntry);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fDB", &fDB);
      R__insp.InspectMember(fDB, "fDB.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fInsertQuery", &fInsertQuery);
      R__insp.InspectMember(fInsertQuery, "fInsertQuery.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fQuery", &fQuery);
      R__insp.InspectMember(fQuery, "fQuery.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTable", &fTable);
      R__insp.InspectMember(fTable, "fTable.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fResult", &fResult);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fRow", &fRow);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fServer", &fServer);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fBranchChecked", &fBranchChecked);
      TTree::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrapper around operator delete
   static void delete_TTreeSQL(void *p) {
      delete ((::TTreeSQL*)p);
   }
   static void deleteArray_TTreeSQL(void *p) {
      delete [] ((::TTreeSQL*)p);
   }
   static void destruct_TTreeSQL(void *p) {
      typedef ::TTreeSQL current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around the directory auto add.
   static void directoryAutoAdd_TTreeSQL(void *p, TDirectory *dir) {
      ((::TTreeSQL*)p)->DirectoryAutoAdd(dir);
   }
} // end of namespace ROOT for class ::TTreeSQL

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

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

//______________________________________________________________________________
void TBufferSQL::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TBufferSQL.
      TClass *R__cl = ::TBufferSQL::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fIter", (void*)&fIter);
      R__insp.InspectMember("vector<int,allocator<int> >::const_iterator", (void*)&fIter, "fIter.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fColumnVec", &fColumnVec);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fInsertQuery", &fInsertQuery);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fRowPtr", &fRowPtr);
      TBufferFile::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TBufferSQL(void *p) {
      return  p ? new(p) ::TBufferSQL : new ::TBufferSQL;
   }
   static void *newArray_TBufferSQL(Long_t nElements, void *p) {
      return p ? new(p) ::TBufferSQL[nElements] : new ::TBufferSQL[nElements];
   }
   // Wrapper around operator delete
   static void delete_TBufferSQL(void *p) {
      delete ((::TBufferSQL*)p);
   }
   static void deleteArray_TBufferSQL(void *p) {
      delete [] ((::TBufferSQL*)p);
   }
   static void destruct_TBufferSQL(void *p) {
      typedef ::TBufferSQL current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TBufferSQL

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

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

//______________________________________________________________________________
void TBasketSQL::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TBasketSQL.
      TClass *R__cl = ::TBasketSQL::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fResultPtr", &fResultPtr);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fRowPtr", &fRowPtr);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fInsertQuery", &fInsertQuery);
      TBasket::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TBasketSQL(void *p) {
      return  p ? new(p) ::TBasketSQL : new ::TBasketSQL;
   }
   static void *newArray_TBasketSQL(Long_t nElements, void *p) {
      return p ? new(p) ::TBasketSQL[nElements] : new ::TBasketSQL[nElements];
   }
   // Wrapper around operator delete
   static void delete_TBasketSQL(void *p) {
      delete ((::TBasketSQL*)p);
   }
   static void deleteArray_TBasketSQL(void *p) {
      delete [] ((::TBasketSQL*)p);
   }
   static void destruct_TBasketSQL(void *p) {
      typedef ::TBasketSQL current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TBasketSQL

//______________________________________________________________________________
void TChain::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TChain.
      TClass *R__cl = ::TChain::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTreeOffsetLen", &fTreeOffsetLen);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNtrees", &fNtrees);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTreeNumber", &fTreeNumber);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fTreeOffset", &fTreeOffset);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fCanDeleteRefs", &fCanDeleteRefs);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fTree", &fTree);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fFile", &fFile);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fFiles", &fFiles);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fStatus", &fStatus);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fProofChain", &fProofChain);
      TTree::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TChain(void *p) {
      return  p ? new(p) ::TChain : new ::TChain;
   }
   static void *newArray_TChain(Long_t nElements, void *p) {
      return p ? new(p) ::TChain[nElements] : new ::TChain[nElements];
   }
   // Wrapper around operator delete
   static void delete_TChain(void *p) {
      delete ((::TChain*)p);
   }
   static void deleteArray_TChain(void *p) {
      delete [] ((::TChain*)p);
   }
   static void destruct_TChain(void *p) {
      typedef ::TChain current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around the directory auto add.
   static void directoryAutoAdd_TChain(void *p, TDirectory *dir) {
      ((::TChain*)p)->DirectoryAutoAdd(dir);
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TChain(TBuffer &buf, void *obj) {
      ((::TChain*)obj)->::TChain::Streamer(buf);
   }
} // end of namespace ROOT for class ::TChain

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

   UInt_t R__s, R__c;
   if (R__b.IsReading()) {
      Version_t R__v = R__b.ReadVersion(&R__s, &R__c); if (R__v) { }
      TNamed::Streamer(R__b);
      R__b >> fEntries;
      R__b >> fNPackets;
      R__b >> fPacketSize;
      R__b >> fStatus;
      R__b.CheckByteCount(R__s, R__c, TChainElement::IsA());
   } else {
      R__c = R__b.WriteVersion(TChainElement::IsA(), kTRUE);
      TNamed::Streamer(R__b);
      R__b << fEntries;
      R__b << fNPackets;
      R__b << fPacketSize;
      R__b << fStatus;
      R__b.SetByteCount(R__c, kTRUE);
   }
}

//______________________________________________________________________________
void TChainElement::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TChainElement.
      TClass *R__cl = ::TChainElement::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fEntries", &fEntries);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNPackets", &fNPackets);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fPacketSize", &fPacketSize);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fStatus", &fStatus);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fBaddress", &fBaddress);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fBaddressClassName", &fBaddressClassName);
      R__insp.InspectMember(fBaddressClassName, "fBaddressClassName.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fBaddressType", &fBaddressType);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fBaddressIsPtr", &fBaddressIsPtr);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fPackets", &fPackets);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fBranchPtr", &fBranchPtr);
      TNamed::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TChainElement(void *p) {
      return  p ? new(p) ::TChainElement : new ::TChainElement;
   }
   static void *newArray_TChainElement(Long_t nElements, void *p) {
      return p ? new(p) ::TChainElement[nElements] : new ::TChainElement[nElements];
   }
   // Wrapper around operator delete
   static void delete_TChainElement(void *p) {
      delete ((::TChainElement*)p);
   }
   static void deleteArray_TChainElement(void *p) {
      delete [] ((::TChainElement*)p);
   }
   static void destruct_TChainElement(void *p) {
      typedef ::TChainElement current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TChainElement(TBuffer &buf, void *obj) {
      ((::TChainElement*)obj)->::TChainElement::Streamer(buf);
   }
} // end of namespace ROOT for class ::TChainElement

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

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

//______________________________________________________________________________
void TCut::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TCut.
      TClass *R__cl = ::TCut::IsA();
      if (R__cl || R__insp.IsA()) { }
      TNamed::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TCut(void *p) {
      return  p ? new(p) ::TCut : new ::TCut;
   }
   static void *newArray_TCut(Long_t nElements, void *p) {
      return p ? new(p) ::TCut[nElements] : new ::TCut[nElements];
   }
   // Wrapper around operator delete
   static void delete_TCut(void *p) {
      delete ((::TCut*)p);
   }
   static void deleteArray_TCut(void *p) {
      delete [] ((::TCut*)p);
   }
   static void destruct_TCut(void *p) {
      typedef ::TCut current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TCut

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

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

//______________________________________________________________________________
void TEntryList::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TEntryList.
      TClass *R__cl = ::TEntryList::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fLists", &fLists);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fCurrent", &fCurrent);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNBlocks", &fNBlocks);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fBlocks", &fBlocks);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fN", &fN);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fEntriesToProcess", &fEntriesToProcess);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTreeName", &fTreeName);
      R__insp.InspectMember(fTreeName, "fTreeName.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fFileName", &fFileName);
      R__insp.InspectMember(fFileName, "fFileName.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fStringHash", &fStringHash);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTreeNumber", &fTreeNumber);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fLastIndexQueried", &fLastIndexQueried);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fLastIndexReturned", &fLastIndexReturned);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fShift", &fShift);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fDirectory", &fDirectory);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fReapply", &fReapply);
      TNamed::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TEntryList(void *p) {
      return  p ? new(p) ::TEntryList : new ::TEntryList;
   }
   static void *newArray_TEntryList(Long_t nElements, void *p) {
      return p ? new(p) ::TEntryList[nElements] : new ::TEntryList[nElements];
   }
   // Wrapper around operator delete
   static void delete_TEntryList(void *p) {
      delete ((::TEntryList*)p);
   }
   static void deleteArray_TEntryList(void *p) {
      delete [] ((::TEntryList*)p);
   }
   static void destruct_TEntryList(void *p) {
      typedef ::TEntryList current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around the directory auto add.
   static void directoryAutoAdd_TEntryList(void *p, TDirectory *dir) {
      ((::TEntryList*)p)->DirectoryAutoAdd(dir);
   }
} // end of namespace ROOT for class ::TEntryList

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

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

//______________________________________________________________________________
void TEntryListFromFile::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TEntryListFromFile.
      TClass *R__cl = ::TEntryListFromFile::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fListFileName", &fListFileName);
      R__insp.InspectMember(fListFileName, "fListFileName.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fListName", &fListName);
      R__insp.InspectMember(fListName, "fListName.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNFiles", &fNFiles);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fListOffset", &fListOffset);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fFile", &fFile);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fFileNames", &fFileNames);
      TEntryList::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TEntryListFromFile(void *p) {
      return  p ? new(p) ::TEntryListFromFile : new ::TEntryListFromFile;
   }
   static void *newArray_TEntryListFromFile(Long_t nElements, void *p) {
      return p ? new(p) ::TEntryListFromFile[nElements] : new ::TEntryListFromFile[nElements];
   }
   // Wrapper around operator delete
   static void delete_TEntryListFromFile(void *p) {
      delete ((::TEntryListFromFile*)p);
   }
   static void deleteArray_TEntryListFromFile(void *p) {
      delete [] ((::TEntryListFromFile*)p);
   }
   static void destruct_TEntryListFromFile(void *p) {
      typedef ::TEntryListFromFile current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around the directory auto add.
   static void directoryAutoAdd_TEntryListFromFile(void *p, TDirectory *dir) {
      ((::TEntryListFromFile*)p)->DirectoryAutoAdd(dir);
   }
} // end of namespace ROOT for class ::TEntryListFromFile

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

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

//______________________________________________________________________________
void TEntryListBlock::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TEntryListBlock.
      TClass *R__cl = ::TEntryListBlock::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNPassed", &fNPassed);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fN", &fN);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fIndices", &fIndices);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fType", &fType);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fPassing", &fPassing);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fCurrent", &fCurrent);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fLastIndexQueried", &fLastIndexQueried);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fLastIndexReturned", &fLastIndexReturned);
      TObject::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TEntryListBlock(void *p) {
      return  p ? new(p) ::TEntryListBlock : new ::TEntryListBlock;
   }
   static void *newArray_TEntryListBlock(Long_t nElements, void *p) {
      return p ? new(p) ::TEntryListBlock[nElements] : new ::TEntryListBlock[nElements];
   }
   // Wrapper around operator delete
   static void delete_TEntryListBlock(void *p) {
      delete ((::TEntryListBlock*)p);
   }
   static void deleteArray_TEntryListBlock(void *p) {
      delete [] ((::TEntryListBlock*)p);
   }
   static void destruct_TEntryListBlock(void *p) {
      typedef ::TEntryListBlock current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TEntryListBlock

//______________________________________________________________________________
void TEventList::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TEventList.
      TClass *R__cl = ::TEventList::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fN", &fN);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fSize", &fSize);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fDelta", &fDelta);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fReapply", &fReapply);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fList", &fList);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fDirectory", &fDirectory);
      TNamed::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TEventList(void *p) {
      return  p ? new(p) ::TEventList : new ::TEventList;
   }
   static void *newArray_TEventList(Long_t nElements, void *p) {
      return p ? new(p) ::TEventList[nElements] : new ::TEventList[nElements];
   }
   // Wrapper around operator delete
   static void delete_TEventList(void *p) {
      delete ((::TEventList*)p);
   }
   static void deleteArray_TEventList(void *p) {
      delete [] ((::TEventList*)p);
   }
   static void destruct_TEventList(void *p) {
      typedef ::TEventList current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around the directory auto add.
   static void directoryAutoAdd_TEventList(void *p, TDirectory *dir) {
      ((::TEventList*)p)->DirectoryAutoAdd(dir);
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TEventList(TBuffer &buf, void *obj) {
      ((::TEventList*)obj)->::TEventList::Streamer(buf);
   }
} // end of namespace ROOT for class ::TEventList

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

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

//______________________________________________________________________________
void TFriendElement::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TFriendElement.
      TClass *R__cl = ::TFriendElement::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fParentTree", &fParentTree);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fTree", &fTree);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fFile", &fFile);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTreeName", &fTreeName);
      R__insp.InspectMember(fTreeName, "fTreeName.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fOwnFile", &fOwnFile);
      TNamed::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TFriendElement(void *p) {
      return  p ? new(p) ::TFriendElement : new ::TFriendElement;
   }
   static void *newArray_TFriendElement(Long_t nElements, void *p) {
      return p ? new(p) ::TFriendElement[nElements] : new ::TFriendElement[nElements];
   }
   // Wrapper around operator delete
   static void delete_TFriendElement(void *p) {
      delete ((::TFriendElement*)p);
   }
   static void deleteArray_TFriendElement(void *p) {
      delete [] ((::TFriendElement*)p);
   }
   static void destruct_TFriendElement(void *p) {
      typedef ::TFriendElement current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TFriendElement

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

   TIterator::Streamer(R__b);
}

//______________________________________________________________________________
void TTreeFriendLeafIter::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TTreeFriendLeafIter.
      TClass *R__cl = ::TTreeFriendLeafIter::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fTree", &fTree);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fLeafIter", &fLeafIter);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fTreeIter", &fTreeIter);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fDirection", &fDirection);
      TIterator::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrapper around operator delete
   static void delete_TTreeFriendLeafIter(void *p) {
      delete ((::TTreeFriendLeafIter*)p);
   }
   static void deleteArray_TTreeFriendLeafIter(void *p) {
      delete [] ((::TTreeFriendLeafIter*)p);
   }
   static void destruct_TTreeFriendLeafIter(void *p) {
      typedef ::TTreeFriendLeafIter current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TTreeFriendLeafIter(TBuffer &buf, void *obj) {
      ((::TTreeFriendLeafIter*)obj)->::TTreeFriendLeafIter::Streamer(buf);
   }
} // end of namespace ROOT for class ::TTreeFriendLeafIter

//______________________________________________________________________________
void TLeaf::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TLeaf.
      TClass *R__cl = ::TLeaf::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNdata", &fNdata);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fLen", &fLen);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fLenType", &fLenType);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fOffset", &fOffset);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fIsRange", &fIsRange);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fIsUnsigned", &fIsUnsigned);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fLeafCount", &fLeafCount);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fBranch", &fBranch);
      TNamed::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TLeaf(void *p) {
      return  p ? new(p) ::TLeaf : new ::TLeaf;
   }
   static void *newArray_TLeaf(Long_t nElements, void *p) {
      return p ? new(p) ::TLeaf[nElements] : new ::TLeaf[nElements];
   }
   // Wrapper around operator delete
   static void delete_TLeaf(void *p) {
      delete ((::TLeaf*)p);
   }
   static void deleteArray_TLeaf(void *p) {
      delete [] ((::TLeaf*)p);
   }
   static void destruct_TLeaf(void *p) {
      typedef ::TLeaf current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TLeaf(TBuffer &buf, void *obj) {
      ((::TLeaf*)obj)->::TLeaf::Streamer(buf);
   }
} // end of namespace ROOT for class ::TLeaf

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

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

//______________________________________________________________________________
void TLeafElement::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TLeafElement.
      TClass *R__cl = ::TLeafElement::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fAbsAddress", &fAbsAddress);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fID", &fID);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fType", &fType);
      TLeaf::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TLeafElement(void *p) {
      return  p ? new(p) ::TLeafElement : new ::TLeafElement;
   }
   static void *newArray_TLeafElement(Long_t nElements, void *p) {
      return p ? new(p) ::TLeafElement[nElements] : new ::TLeafElement[nElements];
   }
   // Wrapper around operator delete
   static void delete_TLeafElement(void *p) {
      delete ((::TLeafElement*)p);
   }
   static void deleteArray_TLeafElement(void *p) {
      delete [] ((::TLeafElement*)p);
   }
   static void destruct_TLeafElement(void *p) {
      typedef ::TLeafElement current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TLeafElement

//______________________________________________________________________________
void TLeafObject::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TLeafObject.
      TClass *R__cl = ::TLeafObject::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fClass", (void*)&fClass);
      R__insp.InspectMember("TClassRef", (void*)&fClass, "fClass.", true);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fObjAddress", &fObjAddress);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fVirtual", &fVirtual);
      TLeaf::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TLeafObject(void *p) {
      return  p ? new(p) ::TLeafObject : new ::TLeafObject;
   }
   static void *newArray_TLeafObject(Long_t nElements, void *p) {
      return p ? new(p) ::TLeafObject[nElements] : new ::TLeafObject[nElements];
   }
   // Wrapper around operator delete
   static void delete_TLeafObject(void *p) {
      delete ((::TLeafObject*)p);
   }
   static void deleteArray_TLeafObject(void *p) {
      delete [] ((::TLeafObject*)p);
   }
   static void destruct_TLeafObject(void *p) {
      typedef ::TLeafObject current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TLeafObject(TBuffer &buf, void *obj) {
      ((::TLeafObject*)obj)->::TLeafObject::Streamer(buf);
   }
} // end of namespace ROOT for class ::TLeafObject

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

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

//______________________________________________________________________________
void TLeafB::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TLeafB.
      TClass *R__cl = ::TLeafB::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMinimum", &fMinimum);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMaximum", &fMaximum);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fValue", &fValue);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fPointer", &fPointer);
      TLeaf::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TLeafB(void *p) {
      return  p ? new(p) ::TLeafB : new ::TLeafB;
   }
   static void *newArray_TLeafB(Long_t nElements, void *p) {
      return p ? new(p) ::TLeafB[nElements] : new ::TLeafB[nElements];
   }
   // Wrapper around operator delete
   static void delete_TLeafB(void *p) {
      delete ((::TLeafB*)p);
   }
   static void deleteArray_TLeafB(void *p) {
      delete [] ((::TLeafB*)p);
   }
   static void destruct_TLeafB(void *p) {
      typedef ::TLeafB current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TLeafB

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

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

//______________________________________________________________________________
void TLeafC::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TLeafC.
      TClass *R__cl = ::TLeafC::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMinimum", &fMinimum);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMaximum", &fMaximum);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fValue", &fValue);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fPointer", &fPointer);
      TLeaf::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TLeafC(void *p) {
      return  p ? new(p) ::TLeafC : new ::TLeafC;
   }
   static void *newArray_TLeafC(Long_t nElements, void *p) {
      return p ? new(p) ::TLeafC[nElements] : new ::TLeafC[nElements];
   }
   // Wrapper around operator delete
   static void delete_TLeafC(void *p) {
      delete ((::TLeafC*)p);
   }
   static void deleteArray_TLeafC(void *p) {
      delete [] ((::TLeafC*)p);
   }
   static void destruct_TLeafC(void *p) {
      typedef ::TLeafC current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TLeafC

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

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

//______________________________________________________________________________
void TLeafD::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TLeafD.
      TClass *R__cl = ::TLeafD::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMinimum", &fMinimum);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMaximum", &fMaximum);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fValue", &fValue);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fPointer", &fPointer);
      TLeaf::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TLeafD(void *p) {
      return  p ? new(p) ::TLeafD : new ::TLeafD;
   }
   static void *newArray_TLeafD(Long_t nElements, void *p) {
      return p ? new(p) ::TLeafD[nElements] : new ::TLeafD[nElements];
   }
   // Wrapper around operator delete
   static void delete_TLeafD(void *p) {
      delete ((::TLeafD*)p);
   }
   static void deleteArray_TLeafD(void *p) {
      delete [] ((::TLeafD*)p);
   }
   static void destruct_TLeafD(void *p) {
      typedef ::TLeafD current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TLeafD

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

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

//______________________________________________________________________________
void TLeafF::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TLeafF.
      TClass *R__cl = ::TLeafF::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMinimum", &fMinimum);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMaximum", &fMaximum);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fValue", &fValue);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fPointer", &fPointer);
      TLeaf::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TLeafF(void *p) {
      return  p ? new(p) ::TLeafF : new ::TLeafF;
   }
   static void *newArray_TLeafF(Long_t nElements, void *p) {
      return p ? new(p) ::TLeafF[nElements] : new ::TLeafF[nElements];
   }
   // Wrapper around operator delete
   static void delete_TLeafF(void *p) {
      delete ((::TLeafF*)p);
   }
   static void deleteArray_TLeafF(void *p) {
      delete [] ((::TLeafF*)p);
   }
   static void destruct_TLeafF(void *p) {
      typedef ::TLeafF current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TLeafF

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

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

//______________________________________________________________________________
void TLeafI::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TLeafI.
      TClass *R__cl = ::TLeafI::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMinimum", &fMinimum);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMaximum", &fMaximum);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fValue", &fValue);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fPointer", &fPointer);
      TLeaf::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TLeafI(void *p) {
      return  p ? new(p) ::TLeafI : new ::TLeafI;
   }
   static void *newArray_TLeafI(Long_t nElements, void *p) {
      return p ? new(p) ::TLeafI[nElements] : new ::TLeafI[nElements];
   }
   // Wrapper around operator delete
   static void delete_TLeafI(void *p) {
      delete ((::TLeafI*)p);
   }
   static void deleteArray_TLeafI(void *p) {
      delete [] ((::TLeafI*)p);
   }
   static void destruct_TLeafI(void *p) {
      typedef ::TLeafI current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TLeafI

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

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

//______________________________________________________________________________
void TLeafS::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TLeafS.
      TClass *R__cl = ::TLeafS::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMinimum", &fMinimum);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMaximum", &fMaximum);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fValue", &fValue);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fPointer", &fPointer);
      TLeaf::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TLeafS(void *p) {
      return  p ? new(p) ::TLeafS : new ::TLeafS;
   }
   static void *newArray_TLeafS(Long_t nElements, void *p) {
      return p ? new(p) ::TLeafS[nElements] : new ::TLeafS[nElements];
   }
   // Wrapper around operator delete
   static void delete_TLeafS(void *p) {
      delete ((::TLeafS*)p);
   }
   static void deleteArray_TLeafS(void *p) {
      delete [] ((::TLeafS*)p);
   }
   static void destruct_TLeafS(void *p) {
      typedef ::TLeafS current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TLeafS

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

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

//______________________________________________________________________________
void TLeafL::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TLeafL.
      TClass *R__cl = ::TLeafL::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMinimum", &fMinimum);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMaximum", &fMaximum);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fValue", &fValue);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fPointer", &fPointer);
      TLeaf::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TLeafL(void *p) {
      return  p ? new(p) ::TLeafL : new ::TLeafL;
   }
   static void *newArray_TLeafL(Long_t nElements, void *p) {
      return p ? new(p) ::TLeafL[nElements] : new ::TLeafL[nElements];
   }
   // Wrapper around operator delete
   static void delete_TLeafL(void *p) {
      delete ((::TLeafL*)p);
   }
   static void deleteArray_TLeafL(void *p) {
      delete [] ((::TLeafL*)p);
   }
   static void destruct_TLeafL(void *p) {
      typedef ::TLeafL current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TLeafL

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

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

//______________________________________________________________________________
void TLeafO::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TLeafO.
      TClass *R__cl = ::TLeafO::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMinimum", &fMinimum);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMaximum", &fMaximum);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fValue", &fValue);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fPointer", &fPointer);
      TLeaf::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TLeafO(void *p) {
      return  p ? new(p) ::TLeafO : new ::TLeafO;
   }
   static void *newArray_TLeafO(Long_t nElements, void *p) {
      return p ? new(p) ::TLeafO[nElements] : new ::TLeafO[nElements];
   }
   // Wrapper around operator delete
   static void delete_TLeafO(void *p) {
      delete ((::TLeafO*)p);
   }
   static void deleteArray_TLeafO(void *p) {
      delete [] ((::TLeafO*)p);
   }
   static void destruct_TLeafO(void *p) {
      typedef ::TLeafO current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TLeafO

//______________________________________________________________________________
void TNtuple::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TNtuple.
      TClass *R__cl = ::TNtuple::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNvar", &fNvar);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fArgs", &fArgs);
      TTree::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TNtuple(void *p) {
      return  p ? new(p) ::TNtuple : new ::TNtuple;
   }
   static void *newArray_TNtuple(Long_t nElements, void *p) {
      return p ? new(p) ::TNtuple[nElements] : new ::TNtuple[nElements];
   }
   // Wrapper around operator delete
   static void delete_TNtuple(void *p) {
      delete ((::TNtuple*)p);
   }
   static void deleteArray_TNtuple(void *p) {
      delete [] ((::TNtuple*)p);
   }
   static void destruct_TNtuple(void *p) {
      typedef ::TNtuple current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around the directory auto add.
   static void directoryAutoAdd_TNtuple(void *p, TDirectory *dir) {
      ((::TNtuple*)p)->DirectoryAutoAdd(dir);
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TNtuple(TBuffer &buf, void *obj) {
      ((::TNtuple*)obj)->::TNtuple::Streamer(buf);
   }
} // end of namespace ROOT for class ::TNtuple

//______________________________________________________________________________
void TNtupleD::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TNtupleD.
      TClass *R__cl = ::TNtupleD::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNvar", &fNvar);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fArgs", &fArgs);
      TTree::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TNtupleD(void *p) {
      return  p ? new(p) ::TNtupleD : new ::TNtupleD;
   }
   static void *newArray_TNtupleD(Long_t nElements, void *p) {
      return p ? new(p) ::TNtupleD[nElements] : new ::TNtupleD[nElements];
   }
   // Wrapper around operator delete
   static void delete_TNtupleD(void *p) {
      delete ((::TNtupleD*)p);
   }
   static void deleteArray_TNtupleD(void *p) {
      delete [] ((::TNtupleD*)p);
   }
   static void destruct_TNtupleD(void *p) {
      typedef ::TNtupleD current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around the directory auto add.
   static void directoryAutoAdd_TNtupleD(void *p, TDirectory *dir) {
      ((::TNtupleD*)p)->DirectoryAutoAdd(dir);
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TNtupleD(TBuffer &buf, void *obj) {
      ((::TNtupleD*)obj)->::TNtupleD::Streamer(buf);
   }
} // end of namespace ROOT for class ::TNtupleD

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

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

//______________________________________________________________________________
void TSelectorCint::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TSelectorCint.
      TClass *R__cl = ::TSelectorCint::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fClass", &fClass);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fFuncVersion", &fFuncVersion);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fFuncInit", &fFuncInit);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fFuncBegin", &fFuncBegin);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fFuncSlBegin", &fFuncSlBegin);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fFuncNotif", &fFuncNotif);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fFuncSlTerm", &fFuncSlTerm);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fFuncTerm", &fFuncTerm);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fFuncCut", &fFuncCut);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fFuncFill", &fFuncFill);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fFuncProc", &fFuncProc);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fFuncOption", &fFuncOption);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fFuncObj", &fFuncObj);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fFuncInp", &fFuncInp);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fFuncOut", &fFuncOut);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fFuncGetAbort", &fFuncGetAbort);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fFuncGetStat", &fFuncGetStat);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fIntSelector", &fIntSelector);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fIsOwner", &fIsOwner);
      TSelector::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TSelectorCint(void *p) {
      return  p ? new(p) ::TSelectorCint : new ::TSelectorCint;
   }
   static void *newArray_TSelectorCint(Long_t nElements, void *p) {
      return p ? new(p) ::TSelectorCint[nElements] : new ::TSelectorCint[nElements];
   }
   // Wrapper around operator delete
   static void delete_TSelectorCint(void *p) {
      delete ((::TSelectorCint*)p);
   }
   static void deleteArray_TSelectorCint(void *p) {
      delete [] ((::TSelectorCint*)p);
   }
   static void destruct_TSelectorCint(void *p) {
      typedef ::TSelectorCint current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TSelectorCint

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

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

//______________________________________________________________________________
void TSelectorList::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TSelectorList.
      TClass *R__cl = ::TSelectorList::IsA();
      if (R__cl || R__insp.IsA()) { }
      TList::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TSelectorList(void *p) {
      return  p ? new(p) ::TSelectorList : new ::TSelectorList;
   }
   static void *newArray_TSelectorList(Long_t nElements, void *p) {
      return p ? new(p) ::TSelectorList[nElements] : new ::TSelectorList[nElements];
   }
   // Wrapper around operator delete
   static void delete_TSelectorList(void *p) {
      delete ((::TSelectorList*)p);
   }
   static void deleteArray_TSelectorList(void *p) {
      delete [] ((::TSelectorList*)p);
   }
   static void destruct_TSelectorList(void *p) {
      typedef ::TSelectorList current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TSelectorList

//______________________________________________________________________________
void TTree::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TTree.
      TClass *R__cl = ::TTree::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fEntries", &fEntries);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTotBytes", &fTotBytes);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fZipBytes", &fZipBytes);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fSavedBytes", &fSavedBytes);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fFlushedBytes", &fFlushedBytes);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fWeight", &fWeight);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTimerInterval", &fTimerInterval);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fScanField", &fScanField);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fUpdate", &fUpdate);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fDefaultEntryOffsetLen", &fDefaultEntryOffsetLen);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMaxEntries", &fMaxEntries);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMaxEntryLoop", &fMaxEntryLoop);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMaxVirtualSize", &fMaxVirtualSize);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fAutoSave", &fAutoSave);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fAutoFlush", &fAutoFlush);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fEstimate", &fEstimate);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fCacheSize", &fCacheSize);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fChainOffset", &fChainOffset);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fReadEntry", &fReadEntry);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTotalBuffers", &fTotalBuffers);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fPacketSize", &fPacketSize);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNfill", &fNfill);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fDebug", &fDebug);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fDebugMin", &fDebugMin);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fDebugMax", &fDebugMax);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMakeClass", &fMakeClass);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fFileNumber", &fFileNumber);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fNotify", &fNotify);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fDirectory", &fDirectory);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fBranches", &fBranches);
      R__insp.InspectMember(fBranches, "fBranches.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fLeaves", &fLeaves);
      R__insp.InspectMember(fLeaves, "fLeaves.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fAliases", &fAliases);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fEventList", &fEventList);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fEntryList", &fEntryList);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fIndexValues", &fIndexValues);
      R__insp.InspectMember(fIndexValues, "fIndexValues.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fIndex", &fIndex);
      R__insp.InspectMember(fIndex, "fIndex.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fTreeIndex", &fTreeIndex);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fFriends", &fFriends);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fUserInfo", &fUserInfo);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fPlayer", &fPlayer);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fClones", &fClones);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fBranchRef", &fBranchRef);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fFriendLockStatus", &fFriendLockStatus);
      TNamed::ShowMembers(R__insp);
      TAttLine::ShowMembers(R__insp);
      TAttFill::ShowMembers(R__insp);
      TAttMarker::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TTree(void *p) {
      return  p ? new(p) ::TTree : new ::TTree;
   }
   static void *newArray_TTree(Long_t nElements, void *p) {
      return p ? new(p) ::TTree[nElements] : new ::TTree[nElements];
   }
   // Wrapper around operator delete
   static void delete_TTree(void *p) {
      delete ((::TTree*)p);
   }
   static void deleteArray_TTree(void *p) {
      delete [] ((::TTree*)p);
   }
   static void destruct_TTree(void *p) {
      typedef ::TTree current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around the directory auto add.
   static void directoryAutoAdd_TTree(void *p, TDirectory *dir) {
      ((::TTree*)p)->DirectoryAutoAdd(dir);
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TTree(TBuffer &buf, void *obj) {
      ((::TTree*)obj)->::TTree::Streamer(buf);
   }
} // end of namespace ROOT for class ::TTree

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

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

//______________________________________________________________________________
void TTreeCloner::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TTreeCloner.
      TClass *R__cl = ::TTreeCloner::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fWarningMsg", &fWarningMsg);
      R__insp.InspectMember(fWarningMsg, "fWarningMsg.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fIsValid", &fIsValid);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNeedConversion", &fNeedConversion);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fOptions", &fOptions);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fFromTree", &fFromTree);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fToTree", &fToTree);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fMethod", &fMethod);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fFromBranches", &fFromBranches);
      R__insp.InspectMember(fFromBranches, "fFromBranches.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fToBranches", &fToBranches);
      R__insp.InspectMember(fToBranches, "fToBranches.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMaxBaskets", &fMaxBaskets);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fBasketBranchNum", &fBasketBranchNum);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fBasketNum", &fBasketNum);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fBasketSeek", &fBasketSeek);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fBasketEntry", &fBasketEntry);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fBasketIndex", &fBasketIndex);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fPidOffset", &fPidOffset);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fCloneMethod", &fCloneMethod);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fToStartEntries", &fToStartEntries);
}

namespace ROOT {
   // Wrapper around operator delete
   static void delete_TTreeCloner(void *p) {
      delete ((::TTreeCloner*)p);
   }
   static void deleteArray_TTreeCloner(void *p) {
      delete [] ((::TTreeCloner*)p);
   }
   static void destruct_TTreeCloner(void *p) {
      typedef ::TTreeCloner current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TTreeCloner

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

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

//______________________________________________________________________________
void TTreeCache::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TTreeCache.
      TClass *R__cl = ::TTreeCache::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fEntryMin", &fEntryMin);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fEntryMax", &fEntryMax);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fEntryCurrent", &fEntryCurrent);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fEntryNext", &fEntryNext);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fZipBytes", &fZipBytes);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNbranches", &fNbranches);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNReadOk", &fNReadOk);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNReadMiss", &fNReadMiss);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNReadPref", &fNReadPref);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fBranches", &fBranches);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fBrNames", &fBrNames);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fOwner", &fOwner);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fTree", &fTree);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fIsLearning", &fIsLearning);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fIsManual", &fIsManual);
      TFileCacheRead::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TTreeCache(void *p) {
      return  p ? new(p) ::TTreeCache : new ::TTreeCache;
   }
   static void *newArray_TTreeCache(Long_t nElements, void *p) {
      return p ? new(p) ::TTreeCache[nElements] : new ::TTreeCache[nElements];
   }
   // Wrapper around operator delete
   static void delete_TTreeCache(void *p) {
      delete ((::TTreeCache*)p);
   }
   static void deleteArray_TTreeCache(void *p) {
      delete [] ((::TTreeCache*)p);
   }
   static void destruct_TTreeCache(void *p) {
      typedef ::TTreeCache current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TTreeCache

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

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

//______________________________________________________________________________
void TTreeCacheUnzip::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TTreeCacheUnzip.
      TClass *R__cl = ::TTreeCacheUnzip::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fUnzipThread[10]", &fUnzipThread);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fActiveThread", &fActiveThread);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fUnzipStartCondition", &fUnzipStartCondition);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fUnzipDoneCondition", &fUnzipDoneCondition);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fParallel", &fParallel);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fAsyncReading", &fAsyncReading);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fMutexList", &fMutexList);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fIOMutex", &fIOMutex);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fCycle", &fCycle);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fLastReadPos", &fLastReadPos);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fBlocksToGo", &fBlocksToGo);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fUnzipLen", &fUnzipLen);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fUnzipChunks", &fUnzipChunks);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fUnzipStatus", &fUnzipStatus);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTotalUnzipBytes", &fTotalUnzipBytes);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNseekMax", &fNseekMax);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fUnzipBufferSize", &fUnzipBufferSize);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNUnzip", &fNUnzip);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNFound", &fNFound);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNStalls", &fNStalls);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNMissed", &fNMissed);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fActiveBlks", (void*)&fActiveBlks);
      R__insp.InspectMember("queue<Int_t>", (void*)&fActiveBlks, "fActiveBlks.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fCompBuffer", &fCompBuffer);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fCompBufferSize", &fCompBufferSize);
      TTreeCache::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TTreeCacheUnzip(void *p) {
      return  p ? new(p) ::TTreeCacheUnzip : new ::TTreeCacheUnzip;
   }
   static void *newArray_TTreeCacheUnzip(Long_t nElements, void *p) {
      return p ? new(p) ::TTreeCacheUnzip[nElements] : new ::TTreeCacheUnzip[nElements];
   }
   // Wrapper around operator delete
   static void delete_TTreeCacheUnzip(void *p) {
      delete ((::TTreeCacheUnzip*)p);
   }
   static void deleteArray_TTreeCacheUnzip(void *p) {
      delete [] ((::TTreeCacheUnzip*)p);
   }
   static void destruct_TTreeCacheUnzip(void *p) {
      typedef ::TTreeCacheUnzip current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TTreeCacheUnzip

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

   TObject::Streamer(R__b);
}

//______________________________________________________________________________
void TVirtualTreePlayer::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TVirtualTreePlayer.
      TClass *R__cl = ::TVirtualTreePlayer::IsA();
      if (R__cl || R__insp.IsA()) { }
      TObject::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrapper around operator delete
   static void delete_TVirtualTreePlayer(void *p) {
      delete ((::TVirtualTreePlayer*)p);
   }
   static void deleteArray_TVirtualTreePlayer(void *p) {
      delete [] ((::TVirtualTreePlayer*)p);
   }
   static void destruct_TVirtualTreePlayer(void *p) {
      typedef ::TVirtualTreePlayer current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TVirtualTreePlayer(TBuffer &buf, void *obj) {
      ((::TVirtualTreePlayer*)obj)->::TVirtualTreePlayer::Streamer(buf);
   }
} // end of namespace ROOT for class ::TVirtualTreePlayer

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

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

//______________________________________________________________________________
void TVirtualIndex::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TVirtualIndex.
      TClass *R__cl = ::TVirtualIndex::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fTree", &fTree);
      TNamed::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrapper around operator delete
   static void delete_TVirtualIndex(void *p) {
      delete ((::TVirtualIndex*)p);
   }
   static void deleteArray_TVirtualIndex(void *p) {
      delete [] ((::TVirtualIndex*)p);
   }
   static void destruct_TVirtualIndex(void *p) {
      typedef ::TVirtualIndex current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TVirtualIndex

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

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

//______________________________________________________________________________
void TTreeResult::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TTreeResult.
      TClass *R__cl = ::TTreeResult::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fColumnCount", &fColumnCount);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fFields", &fFields);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fResult", &fResult);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNextRow", &fNextRow);
      TSQLResult::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TTreeResult(void *p) {
      return  p ? new(p) ::TTreeResult : new ::TTreeResult;
   }
   static void *newArray_TTreeResult(Long_t nElements, void *p) {
      return p ? new(p) ::TTreeResult[nElements] : new ::TTreeResult[nElements];
   }
   // Wrapper around operator delete
   static void delete_TTreeResult(void *p) {
      delete ((::TTreeResult*)p);
   }
   static void deleteArray_TTreeResult(void *p) {
      delete [] ((::TTreeResult*)p);
   }
   static void destruct_TTreeResult(void *p) {
      typedef ::TTreeResult current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TTreeResult

//______________________________________________________________________________
void TTreeRow::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TTreeRow.
      TClass *R__cl = ::TTreeRow::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fColumnCount", &fColumnCount);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fFields", &fFields);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fRow", &fRow);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fOriginal", &fOriginal);
      TSQLRow::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TTreeRow(void *p) {
      return  p ? new(p) ::TTreeRow : new ::TTreeRow;
   }
   static void *newArray_TTreeRow(Long_t nElements, void *p) {
      return p ? new(p) ::TTreeRow[nElements] : new ::TTreeRow[nElements];
   }
   // Wrapper around operator delete
   static void delete_TTreeRow(void *p) {
      delete ((::TTreeRow*)p);
   }
   static void deleteArray_TTreeRow(void *p) {
      delete [] ((::TTreeRow*)p);
   }
   static void destruct_TTreeRow(void *p) {
      typedef ::TTreeRow current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TTreeRow(TBuffer &buf, void *obj) {
      ((::TTreeRow*)obj)->::TTreeRow::Streamer(buf);
   }
} // end of namespace ROOT for class ::TTreeRow

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

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

//______________________________________________________________________________
void TVirtualBranchBrowsable::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TVirtualBranchBrowsable.
      TClass *R__cl = ::TVirtualBranchBrowsable::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fBranch", &fBranch);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fParent", &fParent);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fLeaves", &fLeaves);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fClass", &fClass);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTypeIsPointer", &fTypeIsPointer);
      TNamed::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrapper around operator delete
   static void delete_TVirtualBranchBrowsable(void *p) {
      delete ((::TVirtualBranchBrowsable*)p);
   }
   static void deleteArray_TVirtualBranchBrowsable(void *p) {
      delete [] ((::TVirtualBranchBrowsable*)p);
   }
   static void destruct_TVirtualBranchBrowsable(void *p) {
      typedef ::TVirtualBranchBrowsable current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TVirtualBranchBrowsable

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

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

//______________________________________________________________________________
void TMethodBrowsable::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TMethodBrowsable.
      TClass *R__cl = ::TMethodBrowsable::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fMethod", &fMethod);
      TVirtualBranchBrowsable::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrapper around operator delete
   static void delete_TMethodBrowsable(void *p) {
      delete ((::TMethodBrowsable*)p);
   }
   static void deleteArray_TMethodBrowsable(void *p) {
      delete [] ((::TMethodBrowsable*)p);
   }
   static void destruct_TMethodBrowsable(void *p) {
      typedef ::TMethodBrowsable current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TMethodBrowsable

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

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

//______________________________________________________________________________
void TNonSplitBrowsable::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TNonSplitBrowsable.
      TClass *R__cl = ::TNonSplitBrowsable::IsA();
      if (R__cl || R__insp.IsA()) { }
      TVirtualBranchBrowsable::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrapper around operator delete
   static void delete_TNonSplitBrowsable(void *p) {
      delete ((::TNonSplitBrowsable*)p);
   }
   static void deleteArray_TNonSplitBrowsable(void *p) {
      delete [] ((::TNonSplitBrowsable*)p);
   }
   static void destruct_TNonSplitBrowsable(void *p) {
      typedef ::TNonSplitBrowsable current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TNonSplitBrowsable

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

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

//______________________________________________________________________________
void TCollectionPropertyBrowsable::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TCollectionPropertyBrowsable.
      TClass *R__cl = ::TCollectionPropertyBrowsable::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fDraw", &fDraw);
      R__insp.InspectMember(fDraw, "fDraw.");
      TVirtualBranchBrowsable::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrapper around operator delete
   static void delete_TCollectionPropertyBrowsable(void *p) {
      delete ((::TCollectionPropertyBrowsable*)p);
   }
   static void deleteArray_TCollectionPropertyBrowsable(void *p) {
      delete [] ((::TCollectionPropertyBrowsable*)p);
   }
   static void destruct_TCollectionPropertyBrowsable(void *p) {
      typedef ::TCollectionPropertyBrowsable current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TCollectionPropertyBrowsable

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

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

//______________________________________________________________________________
void TCollectionMethodBrowsable::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TCollectionMethodBrowsable.
      TClass *R__cl = ::TCollectionMethodBrowsable::IsA();
      if (R__cl || R__insp.IsA()) { }
      TMethodBrowsable::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrapper around operator delete
   static void delete_TCollectionMethodBrowsable(void *p) {
      delete ((::TCollectionMethodBrowsable*)p);
   }
   static void deleteArray_TCollectionMethodBrowsable(void *p) {
      delete [] ((::TCollectionMethodBrowsable*)p);
   }
   static void destruct_TCollectionMethodBrowsable(void *p) {
      typedef ::TCollectionMethodBrowsable current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TCollectionMethodBrowsable

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

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

//______________________________________________________________________________
void TSelectorScalar::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TSelectorScalar.
      TClass *R__cl = ::TSelectorScalar::IsA();
      if (R__cl || R__insp.IsA()) { }
      TParameter<long long>::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TSelectorScalar(void *p) {
      return  p ? new(p) ::TSelectorScalar : new ::TSelectorScalar;
   }
   static void *newArray_TSelectorScalar(Long_t nElements, void *p) {
      return p ? new(p) ::TSelectorScalar[nElements] : new ::TSelectorScalar[nElements];
   }
   // Wrapper around operator delete
   static void delete_TSelectorScalar(void *p) {
      delete ((::TSelectorScalar*)p);
   }
   static void deleteArray_TSelectorScalar(void *p) {
      delete [] ((::TSelectorScalar*)p);
   }
   static void destruct_TSelectorScalar(void *p) {
      typedef ::TSelectorScalar current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TSelectorScalar

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

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

//______________________________________________________________________________
void TQueryResult::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TQueryResult.
      TClass *R__cl = ::TQueryResult::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fSeqNum", &fSeqNum);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fDraw", &fDraw);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fStatus", &fStatus);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fStart", &fStart);
      R__insp.InspectMember(fStart, "fStart.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fEnd", &fEnd);
      R__insp.InspectMember(fEnd, "fEnd.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fUsedCPU", &fUsedCPU);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fOptions", &fOptions);
      R__insp.InspectMember(fOptions, "fOptions.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fInputList", &fInputList);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fEntries", &fEntries);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fFirst", &fFirst);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fBytes", &fBytes);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fLogFile", &fLogFile);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fSelecHdr", &fSelecHdr);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fSelecImp", &fSelecImp);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fLibList", &fLibList);
      R__insp.InspectMember(fLibList, "fLibList.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fParList", &fParList);
      R__insp.InspectMember(fParList, "fParList.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fOutputList", &fOutputList);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fFinalized", &fFinalized);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fArchived", &fArchived);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fResultFile", &fResultFile);
      R__insp.InspectMember(fResultFile, "fResultFile.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fInitTime", &fInitTime);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fProcTime", &fProcTime);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNumWrks", &fNumWrks);
      TNamed::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TQueryResult(void *p) {
      return  p ? new(p) ::TQueryResult : new ::TQueryResult;
   }
   static void *newArray_TQueryResult(Long_t nElements, void *p) {
      return p ? new(p) ::TQueryResult[nElements] : new ::TQueryResult[nElements];
   }
   // Wrapper around operator delete
   static void delete_TQueryResult(void *p) {
      delete ((::TQueryResult*)p);
   }
   static void deleteArray_TQueryResult(void *p) {
      delete [] ((::TQueryResult*)p);
   }
   static void destruct_TQueryResult(void *p) {
      typedef ::TQueryResult current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TQueryResult

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

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

//______________________________________________________________________________
void TBranchSTL::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TBranchSTL.
      TClass *R__cl = ::TBranchSTL::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fCollProxy", &fCollProxy);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fParent", &fParent);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fIndArrayCl", &fIndArrayCl);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fInd", (void*)&fInd);
      R__insp.InspectMember("TIndArray", (void*)&fInd, "fInd.", true);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fContName", &fContName);
      R__insp.InspectMember(fContName, "fContName.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fClassName", &fClassName);
      R__insp.InspectMember(fClassName, "fClassName.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fClassVersion", &fClassVersion);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fClCheckSum", &fClCheckSum);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fInfo", &fInfo);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fObject", &fObject);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fID", &fID);
      TBranch::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TBranchSTL(void *p) {
      return  p ? new(p) ::TBranchSTL : new ::TBranchSTL;
   }
   static void *newArray_TBranchSTL(Long_t nElements, void *p) {
      return p ? new(p) ::TBranchSTL[nElements] : new ::TBranchSTL[nElements];
   }
   // Wrapper around operator delete
   static void delete_TBranchSTL(void *p) {
      delete ((::TBranchSTL*)p);
   }
   static void deleteArray_TBranchSTL(void *p) {
      delete [] ((::TBranchSTL*)p);
   }
   static void destruct_TBranchSTL(void *p) {
      typedef ::TBranchSTL current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TBranchSTL

//______________________________________________________________________________
namespace ROOT {
   void TIndArray_ShowMembers(void *obj, TMemberInspector &R__insp)
   {
      // Inspect the data members of an object of class TIndArray.
      typedef ::ROOT::Shadow::TIndArray ShadowClass;
      ShadowClass *sobj = (ShadowClass*)obj;
      if (sobj) { } // Dummy usage just in case there is no datamember.

      TClass *R__cl  = ::ROOT::GenerateInitInstanceLocal((const ::TIndArray*)0x0)->GetClass();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fElems", &sobj->fElems);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fCapacity", &sobj->fCapacity);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fArr", &sobj->fArr);
   }

}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TIndArray(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TIndArray : new ::TIndArray;
   }
   static void *newArray_TIndArray(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TIndArray[nElements] : new ::TIndArray[nElements];
   }
   // Wrapper around operator delete
   static void delete_TIndArray(void *p) {
      delete ((::TIndArray*)p);
   }
   static void deleteArray_TIndArray(void *p) {
      delete [] ((::TIndArray*)p);
   }
   static void destruct_TIndArray(void *p) {
      typedef ::TIndArray current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TIndArray

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

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

//______________________________________________________________________________
void TSelector::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TSelector.
      TClass *R__cl = ::TSelector::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fStatus", &fStatus);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fAbort", &fAbort);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fOption", &fOption);
      R__insp.InspectMember(fOption, "fOption.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fObject", &fObject);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fInput", &fInput);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fOutput", &fOutput);
      TObject::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TSelector(void *p) {
      return  p ? new(p) ::TSelector : new ::TSelector;
   }
   static void *newArray_TSelector(Long_t nElements, void *p) {
      return p ? new(p) ::TSelector[nElements] : new ::TSelector[nElements];
   }
   // Wrapper around operator delete
   static void delete_TSelector(void *p) {
      delete ((::TSelector*)p);
   }
   static void deleteArray_TSelector(void *p) {
      delete [] ((::TSelector*)p);
   }
   static void destruct_TSelector(void *p) {
      typedef ::TSelector current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TSelector

/********************************************************
* tree/tree/src/G__Tree.cxx
* 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__ >= 4 && ((__GNUC_MINOR__ == 2 && __GNUC_PATCHLEVEL__ >= 1) || (__GNUC_MINOR__ >= 3))
#pragma GCC diagnostic ignored "-Wstrict-aliasing"
#endif

extern "C" void G__cpp_reset_tagtableG__Tree();

extern "C" void G__set_cpp_environmentG__Tree() {
  G__add_compiledheader("TObject.h");
  G__add_compiledheader("TMemberInspector.h");
  G__add_compiledheader("TBasket.h");
  G__add_compiledheader("TBasketSQL.h");
  G__add_compiledheader("TBranchBrowsable.h");
  G__add_compiledheader("TBranchClones.h");
  G__add_compiledheader("TBranchElement.h");
  G__add_compiledheader("TBranch.h");
  G__add_compiledheader("TBranchObject.h");
  G__add_compiledheader("TBranchRef.h");
  G__add_compiledheader("TBranchSTL.h");
  G__add_compiledheader("TBufferSQL.h");
  G__add_compiledheader("TChainElement.h");
  G__add_compiledheader("TChain.h");
  G__add_compiledheader("TCut.h");
  G__add_compiledheader("TEntryListBlock.h");
  G__add_compiledheader("TEntryListFromFile.h");
  G__add_compiledheader("TEntryList.h");
  G__add_compiledheader("TEventList.h");
  G__add_compiledheader("TFriendElement.h");
  G__add_compiledheader("TIndArray.h");
  G__add_compiledheader("TLeafB.h");
  G__add_compiledheader("TLeafC.h");
  G__add_compiledheader("TLeafD.h");
  G__add_compiledheader("TLeafElement.h");
  G__add_compiledheader("TLeafF.h");
  G__add_compiledheader("TLeaf.h");
  G__add_compiledheader("TLeafI.h");
  G__add_compiledheader("TLeafL.h");
  G__add_compiledheader("TLeafObject.h");
  G__add_compiledheader("TLeafO.h");
  G__add_compiledheader("TLeafS.h");
  G__add_compiledheader("TNtupleD.h");
  G__add_compiledheader("TNtuple.h");
  G__add_compiledheader("TQueryResult.h");
  G__add_compiledheader("TSelectorCint.h");
  G__add_compiledheader("TSelector.h");
  G__add_compiledheader("TSelectorList.h");
  G__add_compiledheader("TSelectorScalar.h");
  G__add_compiledheader("TTreeCache.h");
  G__add_compiledheader("TTreeCacheUnzip.h");
  G__add_compiledheader("TTreeCloner.h");
  G__add_compiledheader("TTree.h");
  G__add_compiledheader("TTreeResult.h");
  G__add_compiledheader("TTreeRow.h");
  G__add_compiledheader("TTreeSQL.h");
  G__add_compiledheader("TVirtualIndex.h");
  G__add_compiledheader("TVirtualTreePlayer.h");
  G__cpp_reset_tagtableG__Tree();
}
#include <new>
extern "C" int G__cpp_dllrevG__Tree() { return(30051515); }

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

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

static int G__G__Tree_113_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TTree* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 3:
     //m: 3
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TTree(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]));
     } else {
       p = new((void*) gvp) TTree(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]));
     }
     break;
   case 2:
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TTree((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) TTree((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1]));
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__TreeLN_TTree));
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__Tree_113_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((TTree*) G__getstructoffset())->AddBranchToCache((TBranch*) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TTree*) G__getstructoffset())->AddBranchToCache((TBranch*) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_113_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      G__letint(result7, 85, (long) ((TTree*) G__getstructoffset())->AddFriend((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])));
      break;
   case 1:
      G__letint(result7, 85, (long) ((TTree*) G__getstructoffset())->AddFriend((const char*) G__int(libp->para[0])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_113_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TTree*) G__getstructoffset())->AddFriend((const char*) G__int(libp->para[0]), (TFile*) G__int(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_113_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      G__letint(result7, 85, (long) ((TTree*) G__getstructoffset())->AddFriend((TTree*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Bool_t) G__int(libp->para[2])));
      break;
   case 2:
      G__letint(result7, 85, (long) ((TTree*) G__getstructoffset())->AddFriend((TTree*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])));
      break;
   case 1:
      G__letint(result7, 85, (long) ((TTree*) G__getstructoffset())->AddFriend((TTree*) G__int(libp->para[0])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_113_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TTree*) G__getstructoffset())->AddTotBytes((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_113_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TTree*) G__getstructoffset())->AddZipBytes((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_113_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      G__letLonglong(result7, 110, (G__int64) ((TTree*) G__getstructoffset())->AutoSave((Option_t*) G__int(libp->para[0])));
      break;
   case 0:
      G__letLonglong(result7, 110, (G__int64) ((TTree*) G__getstructoffset())->AutoSave());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_113_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 4:
      G__letint(result7, 105, (long) ((TTree*) G__getstructoffset())->Branch((TCollection*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (const char*) G__int(libp->para[3])));
      break;
   case 3:
      G__letint(result7, 105, (long) ((TTree*) G__getstructoffset())->Branch((TCollection*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2])));
      break;
   case 2:
      G__letint(result7, 105, (long) ((TTree*) G__getstructoffset())->Branch((TCollection*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])));
      break;
   case 1:
      G__letint(result7, 105, (long) ((TTree*) G__getstructoffset())->Branch((TCollection*) G__int(libp->para[0])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_113_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      G__letint(result7, 105, (long) ((TTree*) G__getstructoffset())->Branch((TList*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2])));
      break;
   case 2:
      G__letint(result7, 105, (long) ((TTree*) G__getstructoffset())->Branch((TList*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])));
      break;
   case 1:
      G__letint(result7, 105, (long) ((TTree*) G__getstructoffset())->Branch((TList*) G__int(libp->para[0])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_113_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      G__letint(result7, 105, (long) ((TTree*) G__getstructoffset())->Branch((const char*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2])));
      break;
   case 2:
      G__letint(result7, 105, (long) ((TTree*) G__getstructoffset())->Branch((const char*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])));
      break;
   case 1:
      G__letint(result7, 105, (long) ((TTree*) G__getstructoffset())->Branch((const char*) G__int(libp->para[0])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_113_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 4:
      G__letint(result7, 85, (long) ((TTree*) G__getstructoffset())->Branch((const char*) G__int(libp->para[0]), (void*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])));
      break;
   case 3:
      G__letint(result7, 85, (long) ((TTree*) G__getstructoffset())->Branch((const char*) G__int(libp->para[0]), (void*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_113_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 4:
      G__letint(result7, 85, (long) ((TTree*) G__getstructoffset())->Branch((const char*) G__int(libp->para[0]), (char*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])));
      break;
   case 3:
      G__letint(result7, 85, (long) ((TTree*) G__getstructoffset())->Branch((const char*) G__int(libp->para[0]), (char*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_113_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 4:
      G__letint(result7, 85, (long) ((TTree*) G__getstructoffset())->Branch((const char*) G__int(libp->para[0]), (long) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])));
      break;
   case 3:
      G__letint(result7, 85, (long) ((TTree*) G__getstructoffset())->Branch((const char*) G__int(libp->para[0]), (long) G__int(libp->para[1])
, (const char*) G__int(libp->para[2])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_113_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 4:
      G__letint(result7, 85, (long) ((TTree*) G__getstructoffset())->Branch((const char*) G__int(libp->para[0]), (int) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])));
      break;
   case 3:
      G__letint(result7, 85, (long) ((TTree*) G__getstructoffset())->Branch((const char*) G__int(libp->para[0]), (int) G__int(libp->para[1])
, (const char*) G__int(libp->para[2])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_113_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 5:
      G__letint(result7, 85, (long) ((TTree*) G__getstructoffset())->Bronch((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (void*) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4])));
      break;
   case 4:
      G__letint(result7, 85, (long) ((TTree*) G__getstructoffset())->Bronch((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (void*) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])));
      break;
   case 3:
      G__letint(result7, 85, (long) ((TTree*) G__getstructoffset())->Bronch((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (void*) G__int(libp->para[2])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_113_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 5:
      G__letint(result7, 85, (long) ((TTree*) G__getstructoffset())->BranchOld((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (void*) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4])));
      break;
   case 4:
      G__letint(result7, 85, (long) ((TTree*) G__getstructoffset())->BranchOld((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (void*) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])));
      break;
   case 3:
      G__letint(result7, 85, (long) ((TTree*) G__getstructoffset())->BranchOld((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (void*) G__int(libp->para[2])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__Tree_113_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      G__letint(result7, 105, (long) ((TTree*) G__getstructoffset())->BuildIndex((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])));
      break;
   case 1:
      G__letint(result7, 105, (long) ((TTree*) G__getstructoffset())->BuildIndex((const char*) G__int(libp->para[0])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_113_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      G__letint(result7, 85, (long) ((TTree*) G__getstructoffset())->BuildStreamerInfo((TClass*) G__int(libp->para[0]), (void*) G__int(libp->para[1])
, (Bool_t) G__int(libp->para[2])));
      break;
   case 2:
      G__letint(result7, 85, (long) ((TTree*) G__getstructoffset())->BuildStreamerInfo((TClass*) G__int(libp->para[0]), (void*) G__int(libp->para[1])));
      break;
   case 1:
      G__letint(result7, 85, (long) ((TTree*) G__getstructoffset())->BuildStreamerInfo((TClass*) G__int(libp->para[0])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__Tree_113_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      G__letint(result7, 85, (long) ((TTree*) G__getstructoffset())->CloneTree((Long64_t) G__Longlong(libp->para[0]), (Option_t*) G__int(libp->para[1])));
      break;
   case 1:
      G__letint(result7, 85, (long) ((TTree*) G__getstructoffset())->CloneTree((Long64_t) G__Longlong(libp->para[0])));
      break;
   case 0:
      G__letint(result7, 85, (long) ((TTree*) G__getstructoffset())->CloneTree());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_113_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((TTree*) G__getstructoffset())->CopyAddresses((TTree*) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TTree*) G__getstructoffset())->CopyAddresses((TTree*) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_113_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      G__letLonglong(result7, 110, (G__int64) ((TTree*) G__getstructoffset())->CopyEntries((TTree*) G__int(libp->para[0]), (Long64_t) G__Longlong(libp->para[1])
, (Option_t*) G__int(libp->para[2])));
      break;
   case 2:
      G__letLonglong(result7, 110, (G__int64) ((TTree*) G__getstructoffset())->CopyEntries((TTree*) G__int(libp->para[0]), (Long64_t) G__Longlong(libp->para[1])));
      break;
   case 1:
      G__letLonglong(result7, 110, (G__int64) ((TTree*) G__getstructoffset())->CopyEntries((TTree*) G__int(libp->para[0])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_113_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 4:
      G__letint(result7, 85, (long) ((TTree*) G__getstructoffset())->CopyTree((const char*) G__int(libp->para[0]), (Option_t*) G__int(libp->para[1])
, (Long64_t) G__Longlong(libp->para[2]), (Long64_t) G__Longlong(libp->para[3])));
      break;
   case 3:
      G__letint(result7, 85, (long) ((TTree*) G__getstructoffset())->CopyTree((const char*) G__int(libp->para[0]), (Option_t*) G__int(libp->para[1])
, (Long64_t) G__Longlong(libp->para[2])));
      break;
   case 2:
      G__letint(result7, 85, (long) ((TTree*) G__getstructoffset())->CopyTree((const char*) G__int(libp->para[0]), (Option_t*) G__int(libp->para[1])));
      break;
   case 1:
      G__letint(result7, 85, (long) ((TTree*) G__getstructoffset())->CopyTree((const char*) G__int(libp->para[0])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__Tree_113_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TTree*) G__getstructoffset())->DirectoryAutoAdd((TDirectory*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__Tree_113_0_45(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 5:
      G__letLonglong(result7, 110, (G__int64) ((TTree*) G__getstructoffset())->Draw((const char*) G__int(libp->para[0]), *(TCut*) libp->para[1].ref
, (Option_t*) G__int(libp->para[2]), (Long64_t) G__Longlong(libp->para[3])
, (Long64_t) G__Longlong(libp->para[4])));
      break;
   case 4:
      G__letLonglong(result7, 110, (G__int64) ((TTree*) G__getstructoffset())->Draw((const char*) G__int(libp->para[0]), *(TCut*) libp->para[1].ref
, (Option_t*) G__int(libp->para[2]), (Long64_t) G__Longlong(libp->para[3])));
      break;
   case 3:
      G__letLonglong(result7, 110, (G__int64) ((TTree*) G__getstructoffset())->Draw((const char*) G__int(libp->para[0]), *(TCut*) libp->para[1].ref
, (Option_t*) G__int(libp->para[2])));
      break;
   case 2:
      G__letLonglong(result7, 110, (G__int64) ((TTree*) G__getstructoffset())->Draw((const char*) G__int(libp->para[0]), *(TCut*) libp->para[1].ref));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_113_0_46(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 5:
      G__letLonglong(result7, 110, (G__int64) ((TTree*) G__getstructoffset())->Draw((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Option_t*) G__int(libp->para[2]), (Long64_t) G__Longlong(libp->para[3])
, (Long64_t) G__Longlong(libp->para[4])));
      break;
   case 4:
      G__letLonglong(result7, 110, (G__int64) ((TTree*) G__getstructoffset())->Draw((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Option_t*) G__int(libp->para[2]), (Long64_t) G__Longlong(libp->para[3])));
      break;
   case 3:
      G__letLonglong(result7, 110, (G__int64) ((TTree*) G__getstructoffset())->Draw((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Option_t*) G__int(libp->para[2])));
      break;
   case 2:
      G__letLonglong(result7, 110, (G__int64) ((TTree*) G__getstructoffset())->Draw((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_113_0_47(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TTree*) G__getstructoffset())->DropBaskets();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_113_0_48(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TTree*) G__getstructoffset())->DropBuffers((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_113_0_49(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TTree*) G__getstructoffset())->Fill());
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

static int G__G__Tree_113_0_52(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 7:
      G__letint(result7, 105, (long) ((TTree*) G__getstructoffset())->Fit(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]), (Option_t*) G__int(libp->para[3])
, (Option_t*) G__int(libp->para[4]), (Long64_t) G__Longlong(libp->para[5])
, (Long64_t) G__Longlong(libp->para[6])));
      break;
   case 6:
      G__letint(result7, 105, (long) ((TTree*) G__getstructoffset())->Fit((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]), (Option_t*) G__int(libp->para[3])
, (Option_t*) G__int(libp->para[4]), (Long64_t) G__Longlong(libp->para[5])));
      break;
   case 5:
      G__letint(result7, 105, (long) ((TTree*) G__getstructoffset())->Fit((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]), (Option_t*) G__int(libp->para[3])
, (Option_t*) G__int(libp->para[4])));
      break;
   case 4:
      G__letint(result7, 105, (long) ((TTree*) G__getstructoffset())->Fit((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]), (Option_t*) G__int(libp->para[3])));
      break;
   case 3:
      G__letint(result7, 105, (long) ((TTree*) G__getstructoffset())->Fit((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2])));
      break;
   case 2:
      G__letint(result7, 105, (long) ((TTree*) G__getstructoffset())->Fit((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__Tree_113_0_54(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) ((const TTree*) G__getstructoffset())->GetAlias((const char*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_113_0_55(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letLonglong(result7, 110, (G__int64) ((const TTree*) G__getstructoffset())->GetAutoFlush());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_113_0_56(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letLonglong(result7, 110, (G__int64) ((const TTree*) G__getstructoffset())->GetAutoSave());
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__Tree_113_0_58(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TTree*) G__getstructoffset())->GetBranchRef());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_113_0_59(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TTree*) G__getstructoffset())->GetBranchStatus((const char*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__Tree_113_0_61(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letLonglong(result7, 110, (G__int64) ((const TTree*) G__getstructoffset())->GetCacheSize());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_113_0_62(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letLonglong(result7, 110, (G__int64) ((const TTree*) G__getstructoffset())->GetChainEntryNumber((Long64_t) G__Longlong(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_113_0_63(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letLonglong(result7, 110, (G__int64) ((const TTree*) G__getstructoffset())->GetChainOffset());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_113_0_64(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TTree*) G__getstructoffset())->GetCurrentFile());
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__Tree_113_0_66(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letLonglong(result7, 110, (G__int64) ((const TTree*) G__getstructoffset())->GetDebugMax());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_113_0_67(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letLonglong(result7, 110, (G__int64) ((const TTree*) G__getstructoffset())->GetDebugMin());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_113_0_68(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TTree*) G__getstructoffset())->GetDirectory());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_113_0_69(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letLonglong(result7, 110, (G__int64) ((const TTree*) G__getstructoffset())->GetEntries());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_113_0_70(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letLonglong(result7, 110, (G__int64) ((TTree*) G__getstructoffset())->GetEntries((const char*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_113_0_71(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letLonglong(result7, 110, (G__int64) ((const TTree*) G__getstructoffset())->GetEntriesFast());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_113_0_72(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letLonglong(result7, 110, (G__int64) ((const TTree*) G__getstructoffset())->GetEntriesFriend());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_113_0_73(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letLonglong(result7, 110, (G__int64) ((const TTree*) G__getstructoffset())->GetEstimate());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_113_0_74(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      G__letint(result7, 105, (long) ((TTree*) G__getstructoffset())->GetEntry((Long64_t) G__Longlong(libp->para[0]), (Int_t) G__int(libp->para[1])));
      break;
   case 1:
      G__letint(result7, 105, (long) ((TTree*) G__getstructoffset())->GetEntry((Long64_t) G__Longlong(libp->para[0])));
      break;
   case 0:
      G__letint(result7, 105, (long) ((TTree*) G__getstructoffset())->GetEntry());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_113_0_75(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      G__letint(result7, 105, (long) ((TTree*) G__getstructoffset())->GetEvent((Long64_t) G__Longlong(libp->para[0]), (Int_t) G__int(libp->para[1])));
      break;
   case 1:
      G__letint(result7, 105, (long) ((TTree*) G__getstructoffset())->GetEvent((Long64_t) G__Longlong(libp->para[0])));
      break;
   case 0:
      G__letint(result7, 105, (long) ((TTree*) G__getstructoffset())->GetEvent());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_113_0_76(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      G__letint(result7, 105, (long) ((TTree*) G__getstructoffset())->GetEntryWithIndex((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])));
      break;
   case 1:
      G__letint(result7, 105, (long) ((TTree*) G__getstructoffset())->GetEntryWithIndex((Int_t) G__int(libp->para[0])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_113_0_77(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      G__letLonglong(result7, 110, (G__int64) ((const TTree*) G__getstructoffset())->GetEntryNumberWithBestIndex((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])));
      break;
   case 1:
      G__letLonglong(result7, 110, (G__int64) ((const TTree*) G__getstructoffset())->GetEntryNumberWithBestIndex((Int_t) G__int(libp->para[0])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_113_0_78(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      G__letLonglong(result7, 110, (G__int64) ((const TTree*) G__getstructoffset())->GetEntryNumberWithIndex((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])));
      break;
   case 1:
      G__letLonglong(result7, 110, (G__int64) ((const TTree*) G__getstructoffset())->GetEntryNumberWithIndex((Int_t) G__int(libp->para[0])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_113_0_79(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TTree*) G__getstructoffset())->GetEventList());
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__Tree_113_0_81(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letLonglong(result7, 110, (G__int64) ((const TTree*) G__getstructoffset())->GetEntryNumber((Long64_t) G__Longlong(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

static int G__G__Tree_113_0_84(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) ((const TTree*) G__getstructoffset())->GetFriendAlias((TTree*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__Tree_113_0_86(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 73, (long) ((TTree*) G__getstructoffset())->GetIndex());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_113_0_87(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 68, (long) ((TTree*) G__getstructoffset())->GetIndexValues());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_113_0_88(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      G__letint(result7, 85, (long) ((TTree*) G__getstructoffset())->GetIteratorOnAllLeaves((Bool_t) G__int(libp->para[0])));
      break;
   case 0:
      G__letint(result7, 85, (long) ((TTree*) G__getstructoffset())->GetIteratorOnAllLeaves());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

static int G__G__Tree_113_0_93(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TTree*) G__getstructoffset())->GetListOfFriends());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_113_0_94(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TTree*) G__getstructoffset())->GetListOfAliases());
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__Tree_113_0_96(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letLonglong(result7, 110, (G__int64) ((const TTree*) G__getstructoffset())->GetMaxEntryLoop());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_113_0_97(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((TTree*) G__getstructoffset())->GetMaximum((const char*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_113_0_98(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letLonglong(result7, 110, (G__int64) TTree::GetMaxTreeSize());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_113_0_99(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letLonglong(result7, 110, (G__int64) ((const TTree*) G__getstructoffset())->GetMaxVirtualSize());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_113_0_100(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((TTree*) G__getstructoffset())->GetMinimum((const char*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_113_0_101(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TTree*) G__getstructoffset())->GetNbranches());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_113_0_102(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TTree*) G__getstructoffset())->GetNotify());
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

static int G__G__Tree_113_0_105(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letLonglong(result7, 110, (G__int64) ((const TTree*) G__getstructoffset())->GetReadEntry());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_113_0_106(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letLonglong(result7, 110, (G__int64) ((const TTree*) G__getstructoffset())->GetReadEvent());
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

static int G__G__Tree_113_0_109(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letLonglong(result7, 110, (G__int64) ((TTree*) G__getstructoffset())->GetSelectedRows());
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__Tree_113_0_111(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letLonglong(result7, 110, (G__int64) ((const TTree*) G__getstructoffset())->GetTotBytes());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_113_0_112(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TTree*) G__getstructoffset())->GetTree());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_113_0_113(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TTree*) G__getstructoffset())->GetTreeIndex());
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

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

static int G__G__Tree_113_0_123(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 68, (long) ((TTree*) G__getstructoffset())->GetV1());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_113_0_124(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 68, (long) ((TTree*) G__getstructoffset())->GetV2());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_113_0_125(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 68, (long) ((TTree*) G__getstructoffset())->GetV3());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_113_0_126(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 68, (long) ((TTree*) G__getstructoffset())->GetV4());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_113_0_127(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 68, (long) ((TTree*) G__getstructoffset())->GetW());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_113_0_128(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TTree*) G__getstructoffset())->GetWeight());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_113_0_129(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letLonglong(result7, 110, (G__int64) ((const TTree*) G__getstructoffset())->GetZipBytes());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_113_0_130(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TTree*) G__getstructoffset())->IncrementTotalBuffers((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_113_0_132(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      G__letint(result7, 105, (long) ((TTree*) G__getstructoffset())->LoadBaskets((Long64_t) G__Longlong(libp->para[0])));
      break;
   case 0:
      G__letint(result7, 105, (long) ((TTree*) G__getstructoffset())->LoadBaskets());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_113_0_133(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letLonglong(result7, 110, (G__int64) ((TTree*) G__getstructoffset())->LoadTree((Long64_t) G__Longlong(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_113_0_134(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letLonglong(result7, 110, (G__int64) ((TTree*) G__getstructoffset())->LoadTreeFriend((Long64_t) G__Longlong(libp->para[0]), (TTree*) G__int(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_113_0_135(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      G__letint(result7, 105, (long) ((TTree*) G__getstructoffset())->MakeClass((const char*) G__int(libp->para[0]), (Option_t*) G__int(libp->para[1])));
      break;
   case 1:
      G__letint(result7, 105, (long) ((TTree*) G__getstructoffset())->MakeClass((const char*) G__int(libp->para[0])));
      break;
   case 0:
      G__letint(result7, 105, (long) ((TTree*) G__getstructoffset())->MakeClass());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_113_0_136(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      G__letint(result7, 105, (long) ((TTree*) G__getstructoffset())->MakeCode((const char*) G__int(libp->para[0])));
      break;
   case 0:
      G__letint(result7, 105, (long) ((TTree*) G__getstructoffset())->MakeCode());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_113_0_137(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 5:
      G__letint(result7, 105, (long) ((TTree*) G__getstructoffset())->MakeProxy((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]), (const char*) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4])));
      break;
   case 4:
      G__letint(result7, 105, (long) ((TTree*) G__getstructoffset())->MakeProxy((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]), (const char*) G__int(libp->para[3])));
      break;
   case 3:
      G__letint(result7, 105, (long) ((TTree*) G__getstructoffset())->MakeProxy((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2])));
      break;
   case 2:
      G__letint(result7, 105, (long) ((TTree*) G__getstructoffset())->MakeProxy((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])));
      break;
   case 1:
      G__letint(result7, 105, (long) ((TTree*) G__getstructoffset())->MakeProxy((const char*) G__int(libp->para[0])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_113_0_138(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      G__letint(result7, 105, (long) ((TTree*) G__getstructoffset())->MakeSelector((const char*) G__int(libp->para[0])));
      break;
   case 0:
      G__letint(result7, 105, (long) ((TTree*) G__getstructoffset())->MakeSelector());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__Tree_113_0_140(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      G__letLonglong(result7, 110, (G__int64) ((TTree*) G__getstructoffset())->Merge((TCollection*) G__int(libp->para[0]), (Option_t*) G__int(libp->para[1])));
      break;
   case 1:
      G__letLonglong(result7, 110, (G__int64) ((TTree*) G__getstructoffset())->Merge((TCollection*) G__int(libp->para[0])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_113_0_141(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      G__letint(result7, 85, (long) TTree::MergeTrees((TList*) G__int(libp->para[0]), (Option_t*) G__int(libp->para[1])));
      break;
   case 1:
      G__letint(result7, 85, (long) TTree::MergeTrees((TList*) G__int(libp->para[0])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_113_0_143(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      ((TTree*) G__getstructoffset())->OptimizeBaskets((ULong64_t) G__ULonglong(libp->para[0]), (Float_t) G__double(libp->para[1])
, (Option_t*) G__int(libp->para[2]));
      G__setnull(result7);
      break;
   case 2:
      ((TTree*) G__getstructoffset())->OptimizeBaskets((ULong64_t) G__ULonglong(libp->para[0]), (Float_t) G__double(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TTree*) G__getstructoffset())->OptimizeBaskets((ULong64_t) G__ULonglong(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TTree*) G__getstructoffset())->OptimizeBaskets();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_113_0_144(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 5:
      G__letint(result7, 85, (long) ((TTree*) G__getstructoffset())->Principal((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Option_t*) G__int(libp->para[2]), (Long64_t) G__Longlong(libp->para[3])
, (Long64_t) G__Longlong(libp->para[4])));
      break;
   case 4:
      G__letint(result7, 85, (long) ((TTree*) G__getstructoffset())->Principal((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Option_t*) G__int(libp->para[2]), (Long64_t) G__Longlong(libp->para[3])));
      break;
   case 3:
      G__letint(result7, 85, (long) ((TTree*) G__getstructoffset())->Principal((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Option_t*) G__int(libp->para[2])));
      break;
   case 2:
      G__letint(result7, 85, (long) ((TTree*) G__getstructoffset())->Principal((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])));
      break;
   case 1:
      G__letint(result7, 85, (long) ((TTree*) G__getstructoffset())->Principal((const char*) G__int(libp->para[0])));
      break;
   case 0:
      G__letint(result7, 85, (long) ((TTree*) G__getstructoffset())->Principal());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__Tree_113_0_147(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 4:
      G__letLonglong(result7, 110, (G__int64) ((TTree*) G__getstructoffset())->Process((const char*) G__int(libp->para[0]), (Option_t*) G__int(libp->para[1])
, (Long64_t) G__Longlong(libp->para[2]), (Long64_t) G__Longlong(libp->para[3])));
      break;
   case 3:
      G__letLonglong(result7, 110, (G__int64) ((TTree*) G__getstructoffset())->Process((const char*) G__int(libp->para[0]), (Option_t*) G__int(libp->para[1])
, (Long64_t) G__Longlong(libp->para[2])));
      break;
   case 2:
      G__letLonglong(result7, 110, (G__int64) ((TTree*) G__getstructoffset())->Process((const char*) G__int(libp->para[0]), (Option_t*) G__int(libp->para[1])));
      break;
   case 1:
      G__letLonglong(result7, 110, (G__int64) ((TTree*) G__getstructoffset())->Process((const char*) G__int(libp->para[0])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_113_0_148(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 6:
      G__letLonglong(result7, 110, (G__int64) ((TTree*) G__getstructoffset())->Project((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]), (Option_t*) G__int(libp->para[3])
, (Long64_t) G__Longlong(libp->para[4]), (Long64_t) G__Longlong(libp->para[5])));
      break;
   case 5:
      G__letLonglong(result7, 110, (G__int64) ((TTree*) G__getstructoffset())->Project((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]), (Option_t*) G__int(libp->para[3])
, (Long64_t) G__Longlong(libp->para[4])));
      break;
   case 4:
      G__letLonglong(result7, 110, (G__int64) ((TTree*) G__getstructoffset())->Project((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]), (Option_t*) G__int(libp->para[3])));
      break;
   case 3:
      G__letLonglong(result7, 110, (G__int64) ((TTree*) G__getstructoffset())->Project((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2])));
      break;
   case 2:
      G__letLonglong(result7, 110, (G__int64) ((TTree*) G__getstructoffset())->Project((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_113_0_149(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 5:
      G__letint(result7, 85, (long) ((TTree*) G__getstructoffset())->Query((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Option_t*) G__int(libp->para[2]), (Long64_t) G__Longlong(libp->para[3])
, (Long64_t) G__Longlong(libp->para[4])));
      break;
   case 4:
      G__letint(result7, 85, (long) ((TTree*) G__getstructoffset())->Query((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Option_t*) G__int(libp->para[2]), (Long64_t) G__Longlong(libp->para[3])));
      break;
   case 3:
      G__letint(result7, 85, (long) ((TTree*) G__getstructoffset())->Query((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Option_t*) G__int(libp->para[2])));
      break;
   case 2:
      G__letint(result7, 85, (long) ((TTree*) G__getstructoffset())->Query((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])));
      break;
   case 1:
      G__letint(result7, 85, (long) ((TTree*) G__getstructoffset())->Query((const char*) G__int(libp->para[0])));
      break;
   case 0:
      G__letint(result7, 85, (long) ((TTree*) G__getstructoffset())->Query());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_113_0_150(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      G__letLonglong(result7, 110, (G__int64) ((TTree*) G__getstructoffset())->ReadFile((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])));
      break;
   case 1:
      G__letLonglong(result7, 110, (G__int64) ((TTree*) G__getstructoffset())->ReadFile((const char*) G__int(libp->para[0])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_113_0_151(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      G__letLonglong(result7, 110, (G__int64) ((TTree*) G__getstructoffset())->ReadStream(*(istream*) libp->para[0].ref, (const char*) G__int(libp->para[1])));
      break;
   case 1:
      G__letLonglong(result7, 110, (G__int64) ((TTree*) G__getstructoffset())->ReadStream(*(istream*) libp->para[0].ref));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_113_0_152(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TTree*) G__getstructoffset())->Refresh();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_113_0_154(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TTree*) G__getstructoffset())->RemoveFriend((TTree*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__Tree_113_0_156(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TTree*) G__getstructoffset())->ResetBranchAddress((TBranch*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_113_0_157(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TTree*) G__getstructoffset())->ResetBranchAddresses();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_113_0_158(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 5:
      G__letLonglong(result7, 110, (G__int64) ((TTree*) G__getstructoffset())->Scan((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Option_t*) G__int(libp->para[2]), (Long64_t) G__Longlong(libp->para[3])
, (Long64_t) G__Longlong(libp->para[4])));
      break;
   case 4:
      G__letLonglong(result7, 110, (G__int64) ((TTree*) G__getstructoffset())->Scan((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Option_t*) G__int(libp->para[2]), (Long64_t) G__Longlong(libp->para[3])));
      break;
   case 3:
      G__letLonglong(result7, 110, (G__int64) ((TTree*) G__getstructoffset())->Scan((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Option_t*) G__int(libp->para[2])));
      break;
   case 2:
      G__letLonglong(result7, 110, (G__int64) ((TTree*) G__getstructoffset())->Scan((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])));
      break;
   case 1:
      G__letLonglong(result7, 110, (G__int64) ((TTree*) G__getstructoffset())->Scan((const char*) G__int(libp->para[0])));
      break;
   case 0:
      G__letLonglong(result7, 110, (G__int64) ((TTree*) G__getstructoffset())->Scan());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_113_0_159(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((TTree*) G__getstructoffset())->SetAlias((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_113_0_160(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TTree*) G__getstructoffset())->SetAutoSave((Long64_t) G__Longlong(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TTree*) G__getstructoffset())->SetAutoSave();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_113_0_161(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TTree*) G__getstructoffset())->SetAutoFlush((Long64_t) G__Longlong(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TTree*) G__getstructoffset())->SetAutoFlush();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__Tree_113_0_163(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TTree*) G__getstructoffset())->SetBranchAddress((const char*) G__int(libp->para[0]), (void*) G__int(libp->para[1])
, (TClass*) G__int(libp->para[2]), (EDataType) G__int(libp->para[3])
, (Bool_t) G__int(libp->para[4])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_113_0_164(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TTree*) G__getstructoffset())->SetBranchAddress((const char*) G__int(libp->para[0]), (void*) G__int(libp->para[1])
, (TBranch**) G__int(libp->para[2]), (TClass*) G__int(libp->para[3])
, (EDataType) G__int(libp->para[4]), (Bool_t) G__int(libp->para[5])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_113_0_165(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      ((TTree*) G__getstructoffset())->SetBranchStatus((const char*) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1])
, (UInt_t*) G__int(libp->para[2]));
      G__setnull(result7);
      break;
   case 2:
      ((TTree*) G__getstructoffset())->SetBranchStatus((const char*) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TTree*) G__getstructoffset())->SetBranchStatus((const char*) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_113_0_166(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      TTree::SetBranchStyle((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      TTree::SetBranchStyle();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_113_0_167(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TTree*) G__getstructoffset())->SetCacheSize((Long64_t) G__Longlong(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TTree*) G__getstructoffset())->SetCacheSize();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_113_0_168(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TTree*) G__getstructoffset())->SetCacheEntryRange((Long64_t) G__Longlong(libp->para[0]), (Long64_t) G__Longlong(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__Tree_113_0_170(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TTree*) G__getstructoffset())->SetChainOffset((Long64_t) G__Longlong(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TTree*) G__getstructoffset())->SetChainOffset();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_113_0_171(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TTree*) G__getstructoffset())->SetCircular((Long64_t) G__Longlong(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_113_0_172(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      ((TTree*) G__getstructoffset())->SetDebug((Int_t) G__int(libp->para[0]), (Long64_t) G__Longlong(libp->para[1])
, (Long64_t) G__Longlong(libp->para[2]));
      G__setnull(result7);
      break;
   case 2:
      ((TTree*) G__getstructoffset())->SetDebug((Int_t) G__int(libp->para[0]), (Long64_t) G__Longlong(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TTree*) G__getstructoffset())->SetDebug((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TTree*) G__getstructoffset())->SetDebug();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_113_0_173(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((TTree*) G__getstructoffset())->SetDefaultEntryOffsetLen((Int_t) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TTree*) G__getstructoffset())->SetDefaultEntryOffsetLen((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_113_0_174(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TTree*) G__getstructoffset())->SetDirectory((TDirectory*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_113_0_175(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      G__letLonglong(result7, 110, (G__int64) ((TTree*) G__getstructoffset())->SetEntries((Long64_t) G__Longlong(libp->para[0])));
      break;
   case 0:
      G__letLonglong(result7, 110, (G__int64) ((TTree*) G__getstructoffset())->SetEntries());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_113_0_176(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TTree*) G__getstructoffset())->SetEstimate((Long64_t) G__Longlong(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TTree*) G__getstructoffset())->SetEstimate();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__Tree_113_0_178(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TTree*) G__getstructoffset())->SetEventList((TEventList*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_113_0_179(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((TTree*) G__getstructoffset())->SetEntryList((TEntryList*) G__int(libp->para[0]), (Option_t*) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TTree*) G__getstructoffset())->SetEntryList((TEntryList*) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_113_0_180(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TTree*) G__getstructoffset())->SetMakeClass((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_113_0_181(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TTree*) G__getstructoffset())->SetMaxEntryLoop((Long64_t) G__Longlong(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TTree*) G__getstructoffset())->SetMaxEntryLoop();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_113_0_182(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      TTree::SetMaxTreeSize((Long64_t) G__Longlong(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      TTree::SetMaxTreeSize();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_113_0_183(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TTree*) G__getstructoffset())->SetMaxVirtualSize((Long64_t) G__Longlong(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TTree*) G__getstructoffset())->SetMaxVirtualSize();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_113_0_185(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TTree*) G__getstructoffset())->SetNotify((TObject*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_113_0_186(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TTree*) G__getstructoffset())->SetObject((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_113_0_187(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((TTree*) G__getstructoffset())->SetParallelUnzip((Bool_t) G__int(libp->para[0]), (Float_t) G__double(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TTree*) G__getstructoffset())->SetParallelUnzip((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TTree*) G__getstructoffset())->SetParallelUnzip();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

static int G__G__Tree_113_0_190(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TTree*) G__getstructoffset())->SetTreeIndex((TVirtualIndex*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_113_0_191(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((TTree*) G__getstructoffset())->SetWeight((Double_t) G__double(libp->para[0]), (Option_t*) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TTree*) G__getstructoffset())->SetWeight((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TTree*) G__getstructoffset())->SetWeight();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__Tree_113_0_193(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((TTree*) G__getstructoffset())->Show((Long64_t) G__Longlong(libp->para[0]), (Int_t) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TTree*) G__getstructoffset())->Show((Long64_t) G__Longlong(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TTree*) G__getstructoffset())->Show();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_113_0_194(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TTree*) G__getstructoffset())->StartViewer();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_113_0_195(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TTree*) G__getstructoffset())->StopCacheLearningPhase();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_113_0_196(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 6:
      G__letint(result7, 105, (long) ((TTree*) G__getstructoffset())->UnbinnedFit((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]), (Option_t*) G__int(libp->para[3])
, (Long64_t) G__Longlong(libp->para[4]), (Long64_t) G__Longlong(libp->para[5])));
      break;
   case 5:
      G__letint(result7, 105, (long) ((TTree*) G__getstructoffset())->UnbinnedFit((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]), (Option_t*) G__int(libp->para[3])
, (Long64_t) G__Longlong(libp->para[4])));
      break;
   case 4:
      G__letint(result7, 105, (long) ((TTree*) G__getstructoffset())->UnbinnedFit((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]), (Option_t*) G__int(libp->para[3])));
      break;
   case 3:
      G__letint(result7, 105, (long) ((TTree*) G__getstructoffset())->UnbinnedFit((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2])));
      break;
   case 2:
      G__letint(result7, 105, (long) ((TTree*) G__getstructoffset())->UnbinnedFit((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

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

// automatic destructor
typedef TTree G__TTTree;
static int G__G__Tree_113_0_212(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[] (TTree*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TTree*) (soff+(sizeof(TTree)*i)))->~G__TTTree();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TTree*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TTree*) (soff))->~G__TTTree();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


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

static int G__G__Tree_114_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TBranch* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 6:
     //m: 6
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TBranch(
(TTree*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (void*) G__int(libp->para[2]), (const char*) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]), (Int_t) G__int(libp->para[5]));
     } else {
       p = new((void*) gvp) TBranch(
(TTree*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (void*) G__int(libp->para[2]), (const char*) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]), (Int_t) G__int(libp->para[5]));
     }
     break;
   case 5:
     //m: 5
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TBranch(
(TTree*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (void*) G__int(libp->para[2]), (const char*) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]));
     } else {
       p = new((void*) gvp) TBranch(
(TTree*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (void*) G__int(libp->para[2]), (const char*) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]));
     }
     break;
   case 4:
     //m: 4
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TBranch(
(TTree*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (void*) G__int(libp->para[2]), (const char*) G__int(libp->para[3]));
     } else {
       p = new((void*) gvp) TBranch(
(TTree*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (void*) G__int(libp->para[2]), (const char*) G__int(libp->para[3]));
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__TreeLN_TBranch));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_114_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TBranch* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 6:
     //m: 6
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TBranch(
(TBranch*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (void*) G__int(libp->para[2]), (const char*) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]), (Int_t) G__int(libp->para[5]));
     } else {
       p = new((void*) gvp) TBranch(
(TBranch*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (void*) G__int(libp->para[2]), (const char*) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]), (Int_t) G__int(libp->para[5]));
     }
     break;
   case 5:
     //m: 5
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TBranch(
(TBranch*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (void*) G__int(libp->para[2]), (const char*) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]));
     } else {
       p = new((void*) gvp) TBranch(
(TBranch*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (void*) G__int(libp->para[2]), (const char*) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]));
     }
     break;
   case 4:
     //m: 4
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TBranch(
(TBranch*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (void*) G__int(libp->para[2]), (const char*) G__int(libp->para[3]));
     } else {
       p = new((void*) gvp) TBranch(
(TBranch*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (void*) G__int(libp->para[2]), (const char*) G__int(libp->para[3]));
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__TreeLN_TBranch));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_114_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TBranch*) G__getstructoffset())->AddBasket(*(TBasket*) libp->para[0].ref, (Bool_t) G__int(libp->para[1])
, (Long64_t) G__Longlong(libp->para[2]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_114_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TBranch*) G__getstructoffset())->AddLastBasket((Long64_t) G__Longlong(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

static int G__G__Tree_114_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TBranch*) G__getstructoffset())->ExpandBasketArrays();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_114_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TBranch*) G__getstructoffset())->Fill());
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

static int G__G__Tree_114_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TBranch*) G__getstructoffset())->FlushBaskets());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_114_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TBranch*) G__getstructoffset())->FlushOneBasket((UInt_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_114_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) ((const TBranch*) G__getstructoffset())->GetAddress());
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__Tree_114_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 73, (long) ((const TBranch*) G__getstructoffset())->GetBasketBytes());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_114_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 78, (long) ((const TBranch*) G__getstructoffset())->GetBasketEntry());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_114_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letLonglong(result7, 110, (G__int64) ((const TBranch*) G__getstructoffset())->GetBasketSeek((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

static int G__G__Tree_114_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) ((const TBranch*) G__getstructoffset())->GetClassName());
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__Tree_114_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TBranch*) G__getstructoffset())->GetDirectory());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_114_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      G__letint(result7, 105, (long) ((TBranch*) G__getstructoffset())->GetEntry((Long64_t) G__Longlong(libp->para[0]), (Int_t) G__int(libp->para[1])));
      break;
   case 1:
      G__letint(result7, 105, (long) ((TBranch*) G__getstructoffset())->GetEntry((Long64_t) G__Longlong(libp->para[0])));
      break;
   case 0:
      G__letint(result7, 105, (long) ((TBranch*) G__getstructoffset())->GetEntry());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_114_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TBranch*) G__getstructoffset())->GetEntryExport((Long64_t) G__Longlong(libp->para[0]), (Int_t) G__int(libp->para[1])
, (TClonesArray*) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])));
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__Tree_114_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      G__letint(result7, 105, (long) ((TBranch*) G__getstructoffset())->GetEvent((Long64_t) G__Longlong(libp->para[0])));
      break;
   case 0:
      G__letint(result7, 105, (long) ((TBranch*) G__getstructoffset())->GetEvent());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_114_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TBranch*) G__getstructoffset())->GetExpectedType(libp->para[0].ref ? *(TClass**) libp->para[0].ref : *(TClass**) (void*) (&G__Mlong(libp->para[0])), *(EDataType*) libp->para[1].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__Tree_114_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      G__letint(result7, 85, (long) ((TBranch*) G__getstructoffset())->GetFile((Int_t) G__int(libp->para[0])));
      break;
   case 0:
      G__letint(result7, 85, (long) ((TBranch*) G__getstructoffset())->GetFile());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_114_0_42(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) ((const TBranch*) G__getstructoffset())->GetFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

static int G__G__Tree_114_0_45(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letLonglong(result7, 110, (G__int64) ((const TBranch*) G__getstructoffset())->GetReadEntry());
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__Tree_114_0_47(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      G__letLonglong(result7, 110, (G__int64) ((const TBranch*) G__getstructoffset())->GetTotalSize((Option_t*) G__int(libp->para[0])));
      break;
   case 0:
      G__letLonglong(result7, 110, (G__int64) ((const TBranch*) G__getstructoffset())->GetTotalSize());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_114_0_48(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      G__letLonglong(result7, 110, (G__int64) ((const TBranch*) G__getstructoffset())->GetTotBytes((Option_t*) G__int(libp->para[0])));
      break;
   case 0:
      G__letLonglong(result7, 110, (G__int64) ((const TBranch*) G__getstructoffset())->GetTotBytes());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_114_0_49(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      G__letLonglong(result7, 110, (G__int64) ((const TBranch*) G__getstructoffset())->GetZipBytes((Option_t*) G__int(libp->para[0])));
      break;
   case 0:
      G__letLonglong(result7, 110, (G__int64) ((const TBranch*) G__getstructoffset())->GetZipBytes());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_114_0_50(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letLonglong(result7, 110, (G__int64) ((const TBranch*) G__getstructoffset())->GetEntryNumber());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_114_0_51(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letLonglong(result7, 110, (G__int64) ((const TBranch*) G__getstructoffset())->GetFirstEntry());
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

static int G__G__Tree_114_0_58(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letLonglong(result7, 110, (G__int64) ((const TBranch*) G__getstructoffset())->GetEntries());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_114_0_59(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TBranch*) G__getstructoffset())->GetTree());
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

static int G__G__Tree_114_0_62(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TBranch*) G__getstructoffset())->GetMother());
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

static int G__G__Tree_114_0_66(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TBranch*) G__getstructoffset())->KeepCircular((Long64_t) G__Longlong(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_114_0_67(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TBranch*) G__getstructoffset())->LoadBaskets());
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__Tree_114_0_70(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TBranch*) G__getstructoffset())->Refresh((TBranch*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__Tree_114_0_72(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TBranch*) G__getstructoffset())->ResetAddress();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_114_0_73(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TBranch*) G__getstructoffset())->ResetReadEntry();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_114_0_74(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TBranch*) G__getstructoffset())->SetAddress((void*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_114_0_75(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TBranch*) G__getstructoffset())->SetObject((void*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__Tree_114_0_77(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TBranch*) G__getstructoffset())->SetBasketSize((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_114_0_78(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TBranch*) G__getstructoffset())->SetBufferAddress((TBuffer*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__Tree_114_0_80(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TBranch*) G__getstructoffset())->SetEntries((Long64_t) G__Longlong(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_114_0_81(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((TBranch*) G__getstructoffset())->SetEntryOffsetLen((Int_t) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TBranch*) G__getstructoffset())->SetEntryOffsetLen((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_114_0_82(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TBranch*) G__getstructoffset())->SetFirstEntry((Long64_t) G__Longlong(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__Tree_114_0_84(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TBranch*) G__getstructoffset())->SetFile((const char*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_114_0_85(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      G__letint(result7, 103, (long) ((TBranch*) G__getstructoffset())->SetMakeClass((Bool_t) G__int(libp->para[0])));
      break;
   case 0:
      G__letint(result7, 103, (long) ((TBranch*) G__getstructoffset())->SetMakeClass());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

static int G__G__Tree_114_0_88(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TBranch*) G__getstructoffset())->SetTree((TTree*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_114_0_89(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TBranch*) G__getstructoffset())->SetupAddresses();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_114_0_90(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TBranch*) G__getstructoffset())->UpdateAddress();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_114_0_91(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TBranch*) G__getstructoffset())->UpdateFile();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_114_0_92(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TBranch::ResetCount();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

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

// automatic destructor
typedef TBranch G__TTBranch;
static int G__G__Tree_114_0_105(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[] (TBranch*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TBranch*) (soff+(sizeof(TBranch)*i)))->~G__TTBranch();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TBranch*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TBranch*) (soff))->~G__TTBranch();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


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

static int G__G__Tree_115_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TBasket* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TBasket((TDirectory*) G__int(libp->para[0]));
   } else {
     p = new((void*) gvp) TBasket((TDirectory*) G__int(libp->para[0]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__TreeLN_TBasket));
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__Tree_115_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TBasket*) G__getstructoffset())->AdjustSize((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_115_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TBasket*) G__getstructoffset())->DeleteEntryOffset();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_115_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TBasket*) G__getstructoffset())->DropBuffers());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_115_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TBasket*) G__getstructoffset())->GetBranch());
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__Tree_115_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 73, (long) ((const TBasket*) G__getstructoffset())->GetDisplacement());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_115_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 73, (long) ((const TBasket*) G__getstructoffset())->GetEntryOffset());
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

static int G__G__Tree_115_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TBasket*) G__getstructoffset())->MoveEntries((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_115_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TBasket*) G__getstructoffset())->PrepareBasket((Long64_t) G__Longlong(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_115_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TBasket*) G__getstructoffset())->ReadBasketBuffers((Long64_t) G__Longlong(libp->para[0]), (Int_t) G__int(libp->para[1])
, (TFile*) G__int(libp->para[2])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_115_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TBasket*) G__getstructoffset())->ReadBasketBytes((Long64_t) G__Longlong(libp->para[0]), (TFile*) G__int(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_115_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TBasket*) G__getstructoffset())->LoadBasketBuffers((Long64_t) G__Longlong(libp->para[0]), (Int_t) G__int(libp->para[1])
, (TFile*) G__int(libp->para[2])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_115_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letLonglong(result7, 110, (G__int64) ((TBasket*) G__getstructoffset())->CopyTo((TFile*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_115_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TBasket*) G__getstructoffset())->SetBranch((TBranch*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_115_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TBasket*) G__getstructoffset())->SetNevBufSize((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_115_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TBasket*) G__getstructoffset())->SetReadMode();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_115_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TBasket*) G__getstructoffset())->SetWriteMode();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_115_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TBasket*) G__getstructoffset())->Update((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_115_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TBasket*) G__getstructoffset())->Update((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_115_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TBasket*) G__getstructoffset())->WriteBuffer());
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

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

// automatic destructor
typedef TBasket G__TTBasket;
static int G__G__Tree_115_0_43(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[] (TBasket*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TBasket*) (soff+(sizeof(TBasket)*i)))->~G__TTBasket();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TBasket*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TBasket*) (soff))->~G__TTBasket();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


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

static int G__G__Tree_118_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TBufferSQL* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 4
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TBufferSQL(
(TBuffer::EMode) G__int(libp->para[0]), (vector<Int_t>*) G__int(libp->para[1])
, (TString*) G__int(libp->para[2]), (TSQLRow**) G__int(libp->para[3]));
   } else {
     p = new((void*) gvp) TBufferSQL(
(TBuffer::EMode) G__int(libp->para[0]), (vector<Int_t>*) G__int(libp->para[1])
, (TString*) G__int(libp->para[2]), (TSQLRow**) G__int(libp->para[3]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__TreeLN_TBufferSQL));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_118_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TBufferSQL* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 5
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TBufferSQL(
(TBuffer::EMode) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (vector<Int_t>*) G__int(libp->para[2]), (TString*) G__int(libp->para[3])
, (TSQLRow**) G__int(libp->para[4]));
   } else {
     p = new((void*) gvp) TBufferSQL(
(TBuffer::EMode) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (vector<Int_t>*) G__int(libp->para[2]), (TString*) G__int(libp->para[3])
, (TSQLRow**) G__int(libp->para[4]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__TreeLN_TBufferSQL));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_118_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TBufferSQL* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 7:
     //m: 7
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TBufferSQL(
(TBuffer::EMode) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (vector<Int_t>*) G__int(libp->para[2]), (TString*) G__int(libp->para[3])
, (TSQLRow**) G__int(libp->para[4]), (void*) G__int(libp->para[5])
, (Bool_t) G__int(libp->para[6]));
     } else {
       p = new((void*) gvp) TBufferSQL(
(TBuffer::EMode) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (vector<Int_t>*) G__int(libp->para[2]), (TString*) G__int(libp->para[3])
, (TSQLRow**) G__int(libp->para[4]), (void*) G__int(libp->para[5])
, (Bool_t) G__int(libp->para[6]));
     }
     break;
   case 6:
     //m: 6
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TBufferSQL(
(TBuffer::EMode) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (vector<Int_t>*) G__int(libp->para[2]), (TString*) G__int(libp->para[3])
, (TSQLRow**) G__int(libp->para[4]), (void*) G__int(libp->para[5]));
     } else {
       p = new((void*) gvp) TBufferSQL(
(TBuffer::EMode) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (vector<Int_t>*) G__int(libp->para[2]), (TString*) G__int(libp->para[3])
, (TSQLRow**) G__int(libp->para[4]), (void*) G__int(libp->para[5]));
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__TreeLN_TBufferSQL));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_118_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TBufferSQL*) G__getstructoffset())->ResetOffset();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

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

// automatic destructor
typedef TBufferSQL G__TTBufferSQL;
static int G__G__Tree_118_0_84(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[] (TBufferSQL*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TBufferSQL*) (soff+(sizeof(TBufferSQL)*i)))->~G__TTBufferSQL();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TBufferSQL*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TBufferSQL*) (soff))->~G__TTBufferSQL();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


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

static int G__G__Tree_119_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TBasketSQL* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 7
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TBasketSQL(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (TBranch*) G__int(libp->para[2]), (TSQLResult**) G__int(libp->para[3])
, (TString*) G__int(libp->para[4]), (vector<Int_t>*) G__int(libp->para[5])
, (TSQLRow**) G__int(libp->para[6]));
   } else {
     p = new((void*) gvp) TBasketSQL(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (TBranch*) G__int(libp->para[2]), (TSQLResult**) G__int(libp->para[3])
, (TString*) G__int(libp->para[4]), (vector<Int_t>*) G__int(libp->para[5])
, (TSQLRow**) G__int(libp->para[6]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__TreeLN_TBasketSQL));
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__Tree_119_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TBasketSQL*) G__getstructoffset())->CreateBuffer((const char*) G__int(libp->para[0]), *((TString*) G__int(libp->para[1]))
, (vector<Int_t>*) G__int(libp->para[2]), (TBranch*) G__int(libp->para[3])
, (TSQLResult**) G__int(libp->para[4]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

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

// automatic destructor
typedef TBasketSQL G__TTBasketSQL;
static int G__G__Tree_119_0_24(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[] (TBasketSQL*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TBasketSQL*) (soff+(sizeof(TBasketSQL)*i)))->~G__TTBasketSQL();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TBasketSQL*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TBasketSQL*) (soff))->~G__TTBasketSQL();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


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

static int G__G__Tree_135_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TBranchElement* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 8:
     //m: 8
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TBranchElement(
(TTree*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (TStreamerInfo*) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (char*) G__int(libp->para[4]), (Int_t) G__int(libp->para[5])
, (Int_t) G__int(libp->para[6]), (Int_t) G__int(libp->para[7]));
     } else {
       p = new((void*) gvp) TBranchElement(
(TTree*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (TStreamerInfo*) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (char*) G__int(libp->para[4]), (Int_t) G__int(libp->para[5])
, (Int_t) G__int(libp->para[6]), (Int_t) G__int(libp->para[7]));
     }
     break;
   case 7:
     //m: 7
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TBranchElement(
(TTree*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (TStreamerInfo*) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (char*) G__int(libp->para[4]), (Int_t) G__int(libp->para[5])
, (Int_t) G__int(libp->para[6]));
     } else {
       p = new((void*) gvp) TBranchElement(
(TTree*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (TStreamerInfo*) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (char*) G__int(libp->para[4]), (Int_t) G__int(libp->para[5])
, (Int_t) G__int(libp->para[6]));
     }
     break;
   case 6:
     //m: 6
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TBranchElement(
(TTree*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (TStreamerInfo*) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (char*) G__int(libp->para[4]), (Int_t) G__int(libp->para[5]));
     } else {
       p = new((void*) gvp) TBranchElement(
(TTree*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (TStreamerInfo*) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (char*) G__int(libp->para[4]), (Int_t) G__int(libp->para[5]));
     }
     break;
   case 5:
     //m: 5
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TBranchElement(
(TTree*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (TStreamerInfo*) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (char*) G__int(libp->para[4]));
     } else {
       p = new((void*) gvp) TBranchElement(
(TTree*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (TStreamerInfo*) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (char*) G__int(libp->para[4]));
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__TreeLN_TBranchElement));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_135_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TBranchElement* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 6:
     //m: 6
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TBranchElement(
(TTree*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (TClonesArray*) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]), (Int_t) G__int(libp->para[5]));
     } else {
       p = new((void*) gvp) TBranchElement(
(TTree*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (TClonesArray*) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]), (Int_t) G__int(libp->para[5]));
     }
     break;
   case 5:
     //m: 5
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TBranchElement(
(TTree*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (TClonesArray*) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]));
     } else {
       p = new((void*) gvp) TBranchElement(
(TTree*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (TClonesArray*) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]));
     }
     break;
   case 4:
     //m: 4
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TBranchElement(
(TTree*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (TClonesArray*) G__int(libp->para[2]), (Int_t) G__int(libp->para[3]));
     } else {
       p = new((void*) gvp) TBranchElement(
(TTree*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (TClonesArray*) G__int(libp->para[2]), (Int_t) G__int(libp->para[3]));
     }
     break;
   case 3:
     //m: 3
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TBranchElement(
(TTree*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (TClonesArray*) G__int(libp->para[2]));
     } else {
       p = new((void*) gvp) TBranchElement(
(TTree*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (TClonesArray*) G__int(libp->para[2]));
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__TreeLN_TBranchElement));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_135_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TBranchElement* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 6:
     //m: 6
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TBranchElement(
(TTree*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (TVirtualCollectionProxy*) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]), (Int_t) G__int(libp->para[5]));
     } else {
       p = new((void*) gvp) TBranchElement(
(TTree*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (TVirtualCollectionProxy*) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]), (Int_t) G__int(libp->para[5]));
     }
     break;
   case 5:
     //m: 5
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TBranchElement(
(TTree*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (TVirtualCollectionProxy*) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]));
     } else {
       p = new((void*) gvp) TBranchElement(
(TTree*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (TVirtualCollectionProxy*) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]));
     }
     break;
   case 4:
     //m: 4
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TBranchElement(
(TTree*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (TVirtualCollectionProxy*) G__int(libp->para[2]), (Int_t) G__int(libp->para[3]));
     } else {
       p = new((void*) gvp) TBranchElement(
(TTree*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (TVirtualCollectionProxy*) G__int(libp->para[2]), (Int_t) G__int(libp->para[3]));
     }
     break;
   case 3:
     //m: 3
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TBranchElement(
(TTree*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (TVirtualCollectionProxy*) G__int(libp->para[2]));
     } else {
       p = new((void*) gvp) TBranchElement(
(TTree*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (TVirtualCollectionProxy*) G__int(libp->para[2]));
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__TreeLN_TBranchElement));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_135_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TBranchElement* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 8:
     //m: 8
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TBranchElement(
(TBranch*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (TStreamerInfo*) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (char*) G__int(libp->para[4]), (Int_t) G__int(libp->para[5])
, (Int_t) G__int(libp->para[6]), (Int_t) G__int(libp->para[7]));
     } else {
       p = new((void*) gvp) TBranchElement(
(TBranch*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (TStreamerInfo*) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (char*) G__int(libp->para[4]), (Int_t) G__int(libp->para[5])
, (Int_t) G__int(libp->para[6]), (Int_t) G__int(libp->para[7]));
     }
     break;
   case 7:
     //m: 7
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TBranchElement(
(TBranch*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (TStreamerInfo*) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (char*) G__int(libp->para[4]), (Int_t) G__int(libp->para[5])
, (Int_t) G__int(libp->para[6]));
     } else {
       p = new((void*) gvp) TBranchElement(
(TBranch*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (TStreamerInfo*) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (char*) G__int(libp->para[4]), (Int_t) G__int(libp->para[5])
, (Int_t) G__int(libp->para[6]));
     }
     break;
   case 6:
     //m: 6
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TBranchElement(
(TBranch*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (TStreamerInfo*) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (char*) G__int(libp->para[4]), (Int_t) G__int(libp->para[5]));
     } else {
       p = new((void*) gvp) TBranchElement(
(TBranch*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (TStreamerInfo*) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (char*) G__int(libp->para[4]), (Int_t) G__int(libp->para[5]));
     }
     break;
   case 5:
     //m: 5
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TBranchElement(
(TBranch*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (TStreamerInfo*) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (char*) G__int(libp->para[4]));
     } else {
       p = new((void*) gvp) TBranchElement(
(TBranch*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (TStreamerInfo*) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (char*) G__int(libp->para[4]));
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__TreeLN_TBranchElement));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_135_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TBranchElement* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 6:
     //m: 6
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TBranchElement(
(TBranch*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (TClonesArray*) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]), (Int_t) G__int(libp->para[5]));
     } else {
       p = new((void*) gvp) TBranchElement(
(TBranch*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (TClonesArray*) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]), (Int_t) G__int(libp->para[5]));
     }
     break;
   case 5:
     //m: 5
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TBranchElement(
(TBranch*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (TClonesArray*) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]));
     } else {
       p = new((void*) gvp) TBranchElement(
(TBranch*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (TClonesArray*) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]));
     }
     break;
   case 4:
     //m: 4
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TBranchElement(
(TBranch*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (TClonesArray*) G__int(libp->para[2]), (Int_t) G__int(libp->para[3]));
     } else {
       p = new((void*) gvp) TBranchElement(
(TBranch*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (TClonesArray*) G__int(libp->para[2]), (Int_t) G__int(libp->para[3]));
     }
     break;
   case 3:
     //m: 3
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TBranchElement(
(TBranch*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (TClonesArray*) G__int(libp->para[2]));
     } else {
       p = new((void*) gvp) TBranchElement(
(TBranch*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (TClonesArray*) G__int(libp->para[2]));
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__TreeLN_TBranchElement));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_135_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TBranchElement* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 6:
     //m: 6
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TBranchElement(
(TBranch*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (TVirtualCollectionProxy*) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]), (Int_t) G__int(libp->para[5]));
     } else {
       p = new((void*) gvp) TBranchElement(
(TBranch*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (TVirtualCollectionProxy*) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]), (Int_t) G__int(libp->para[5]));
     }
     break;
   case 5:
     //m: 5
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TBranchElement(
(TBranch*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (TVirtualCollectionProxy*) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]));
     } else {
       p = new((void*) gvp) TBranchElement(
(TBranch*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (TVirtualCollectionProxy*) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]));
     }
     break;
   case 4:
     //m: 4
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TBranchElement(
(TBranch*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (TVirtualCollectionProxy*) G__int(libp->para[2]), (Int_t) G__int(libp->para[3]));
     } else {
       p = new((void*) gvp) TBranchElement(
(TBranch*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (TVirtualCollectionProxy*) G__int(libp->para[2]), (Int_t) G__int(libp->para[3]));
     }
     break;
   case 3:
     //m: 3
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TBranchElement(
(TBranch*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (TVirtualCollectionProxy*) G__int(libp->para[2]));
     } else {
       p = new((void*) gvp) TBranchElement(
(TBranch*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (TVirtualCollectionProxy*) G__int(libp->para[2]));
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__TreeLN_TBranchElement));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_135_0_46(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TBranchElement*) G__getstructoffset())->GetBranchCount());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_135_0_47(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TBranchElement*) G__getstructoffset())->GetBranchCount2());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_135_0_48(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 73, (long) ((const TBranchElement*) G__getstructoffset())->GetBranchOffset());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_135_0_49(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 104, (long) ((TBranchElement*) G__getstructoffset())->GetCheckSum());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_135_0_51(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TBranchElement*) G__getstructoffset())->GetClass());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_135_0_52(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) ((const TBranchElement*) G__getstructoffset())->GetClonesName());
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

static int G__G__Tree_135_0_58(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TBranchElement*) G__getstructoffset())->GetInfo());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_135_0_60(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) ((const TBranchElement*) G__getstructoffset())->GetObject());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_135_0_61(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) ((const TBranchElement*) G__getstructoffset())->GetParentName());
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

static int G__G__Tree_135_0_67(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) ((const TBranchElement*) G__getstructoffset())->GetTypeName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_135_0_68(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      G__letdouble(result7, 100, (double) ((const TBranchElement*) G__getstructoffset())->GetValue((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Bool_t) G__int(libp->para[2])));
      break;
   case 2:
      G__letdouble(result7, 100, (double) ((const TBranchElement*) G__getstructoffset())->GetValue((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_135_0_69(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 89, (long) ((const TBranchElement*) G__getstructoffset())->GetValuePointer());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_135_0_70(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TBranchElement*) G__getstructoffset())->GetClassVersion());
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

static int G__G__Tree_135_0_76(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const TBranchElement*) G__getstructoffset())->PrintValue((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_135_0_79(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TBranchElement*) G__getstructoffset())->ResetDeleteObject();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_135_0_84(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TBranchElement*) G__getstructoffset())->SetBranchFolder();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_135_0_85(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TBranchElement*) G__getstructoffset())->SetClassName((const char*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_135_0_87(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TBranchElement*) G__getstructoffset())->SetParentClass((TClass*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_135_0_88(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TBranchElement*) G__getstructoffset())->SetParentName((const char*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_135_0_89(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TBranchElement*) G__getstructoffset())->SetTargetClass((const char*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_135_0_91(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TBranchElement*) G__getstructoffset())->SetType((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

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

// automatic destructor
typedef TBranchElement G__TTBranchElement;
static int G__G__Tree_135_0_105(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[] (TBranchElement*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TBranchElement*) (soff+(sizeof(TBranchElement)*i)))->~G__TTBranchElement();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TBranchElement*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TBranchElement*) (soff))->~G__TTBranchElement();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TVirtualBranchBrowsable */
static int G__G__Tree_136_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const TVirtualBranchBrowsable*) G__getstructoffset())->GetScope(*(TString*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_136_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      G__letint(result7, 105, (long) TVirtualBranchBrowsable::FillListOfBrowsables(*(TList*) libp->para[0].ref, (TBranch*) G__int(libp->para[1])
, (TVirtualBranchBrowsable*) G__int(libp->para[2])));
      break;
   case 2:
      G__letint(result7, 105, (long) TVirtualBranchBrowsable::FillListOfBrowsables(*(TList*) libp->para[0].ref, (TBranch*) G__int(libp->para[1])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_136_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TVirtualBranchBrowsable*) G__getstructoffset())->GetBranch());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_136_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TVirtualBranchBrowsable*) G__getstructoffset())->GetParent());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_136_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TVirtualBranchBrowsable*) G__getstructoffset())->GetClassType());
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__Tree_136_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TVirtualBranchBrowsable*) G__getstructoffset())->GetLeaves());
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

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

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

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

// automatic destructor
typedef TVirtualBranchBrowsable G__TTVirtualBranchBrowsable;
static int G__G__Tree_136_0_32(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[] (TVirtualBranchBrowsable*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TVirtualBranchBrowsable*) (soff+(sizeof(TVirtualBranchBrowsable)*i)))->~G__TTVirtualBranchBrowsable();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TVirtualBranchBrowsable*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TVirtualBranchBrowsable*) (soff))->~G__TTVirtualBranchBrowsable();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TMethodBrowsable */
static int G__G__Tree_141_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      G__letint(result7, 105, (long) TMethodBrowsable::GetBrowsables(*(TList*) libp->para[0].ref, (TBranch*) G__int(libp->para[1])
, (TVirtualBranchBrowsable*) G__int(libp->para[2])));
      break;
   case 2:
      G__letint(result7, 105, (long) TMethodBrowsable::GetBrowsables(*(TList*) libp->para[0].ref, (TBranch*) G__int(libp->para[1])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_141_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) TMethodBrowsable::IsMethodBrowsable((TMethod*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_141_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TMethodBrowsable::Register();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_141_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TMethodBrowsable::Unregister();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

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

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

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

// automatic destructor
typedef TMethodBrowsable G__TTMethodBrowsable;
static int G__G__Tree_141_0_21(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[] (TMethodBrowsable*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TMethodBrowsable*) (soff+(sizeof(TMethodBrowsable)*i)))->~G__TTMethodBrowsable();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TMethodBrowsable*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TMethodBrowsable*) (soff))->~G__TTMethodBrowsable();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TNonSplitBrowsable */
static int G__G__Tree_142_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      G__letint(result7, 105, (long) TNonSplitBrowsable::GetBrowsables(*(TList*) libp->para[0].ref, (TBranch*) G__int(libp->para[1])
, (TVirtualBranchBrowsable*) G__int(libp->para[2])));
      break;
   case 2:
      G__letint(result7, 105, (long) TNonSplitBrowsable::GetBrowsables(*(TList*) libp->para[0].ref, (TBranch*) G__int(libp->para[1])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_142_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TNonSplitBrowsable::Register();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_142_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TNonSplitBrowsable::Unregister();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

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

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

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

// automatic destructor
typedef TNonSplitBrowsable G__TTNonSplitBrowsable;
static int G__G__Tree_142_0_18(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[] (TNonSplitBrowsable*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TNonSplitBrowsable*) (soff+(sizeof(TNonSplitBrowsable)*i)))->~G__TTNonSplitBrowsable();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TNonSplitBrowsable*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TNonSplitBrowsable*) (soff))->~G__TTNonSplitBrowsable();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TCollectionPropertyBrowsable */
static int G__G__Tree_143_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      G__letint(result7, 105, (long) TCollectionPropertyBrowsable::GetBrowsables(*(TList*) libp->para[0].ref, (TBranch*) G__int(libp->para[1])
, (TVirtualBranchBrowsable*) G__int(libp->para[2])));
      break;
   case 2:
      G__letint(result7, 105, (long) TCollectionPropertyBrowsable::GetBrowsables(*(TList*) libp->para[0].ref, (TBranch*) G__int(libp->para[1])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_143_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) ((const TCollectionPropertyBrowsable*) G__getstructoffset())->GetDraw());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_143_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TCollectionPropertyBrowsable::Register();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_143_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TCollectionPropertyBrowsable::Unregister();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

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

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

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

// automatic destructor
typedef TCollectionPropertyBrowsable G__TTCollectionPropertyBrowsable;
static int G__G__Tree_143_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[] (TCollectionPropertyBrowsable*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TCollectionPropertyBrowsable*) (soff+(sizeof(TCollectionPropertyBrowsable)*i)))->~G__TTCollectionPropertyBrowsable();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TCollectionPropertyBrowsable*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TCollectionPropertyBrowsable*) (soff))->~G__TTCollectionPropertyBrowsable();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TCollectionMethodBrowsable */
static int G__G__Tree_144_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      G__letint(result7, 105, (long) TCollectionMethodBrowsable::GetBrowsables(*(TList*) libp->para[0].ref, (TBranch*) G__int(libp->para[1])
, (TVirtualBranchBrowsable*) G__int(libp->para[2])));
      break;
   case 2:
      G__letint(result7, 105, (long) TCollectionMethodBrowsable::GetBrowsables(*(TList*) libp->para[0].ref, (TBranch*) G__int(libp->para[1])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_144_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TCollectionMethodBrowsable::Register();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_144_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TCollectionMethodBrowsable::Unregister();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

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

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

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

// automatic destructor
typedef TCollectionMethodBrowsable G__TTCollectionMethodBrowsable;
static int G__G__Tree_144_0_18(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[] (TCollectionMethodBrowsable*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TCollectionMethodBrowsable*) (soff+(sizeof(TCollectionMethodBrowsable)*i)))->~G__TTCollectionMethodBrowsable();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TCollectionMethodBrowsable*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TCollectionMethodBrowsable*) (soff))->~G__TTCollectionMethodBrowsable();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


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

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

static int G__G__Tree_152_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TLeaf*) G__getstructoffset())->Export((TClonesArray*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__Tree_152_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TLeaf*) G__getstructoffset())->GetBranch());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_152_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TLeaf*) G__getstructoffset())->GetLeafCount());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_152_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TLeaf*) G__getstructoffset())->GetLeafCounter(*(Int_t*) G__Intref(&libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

static int G__G__Tree_152_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 89, (long) ((const TLeaf*) G__getstructoffset())->GetValuePointer());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_152_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) ((const TLeaf*) G__getstructoffset())->GetTypeName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_152_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      G__letdouble(result7, 100, (double) ((const TLeaf*) G__getstructoffset())->GetValue((Int_t) G__int(libp->para[0])));
      break;
   case 0:
      G__letdouble(result7, 100, (double) ((const TLeaf*) G__getstructoffset())->GetValue());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_152_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TLeaf*) G__getstructoffset())->Import((TClonesArray*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

static int G__G__Tree_152_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TLeaf*) G__getstructoffset())->ReadBasketExport(*(TBuffer*) libp->para[0].ref, (TClonesArray*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_152_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TLeaf*) G__getstructoffset())->ReadValue(*(istream*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_152_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      G__letint(result7, 105, (long) ((TLeaf*) G__getstructoffset())->ResetAddress((void*) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1])));
      break;
   case 1:
      G__letint(result7, 105, (long) ((TLeaf*) G__getstructoffset())->ResetAddress((void*) G__int(libp->para[0])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__Tree_152_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TLeaf*) G__getstructoffset())->SetBranch((TBranch*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_152_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TLeaf*) G__getstructoffset())->SetLeafCount((TLeaf*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

static int G__G__Tree_152_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TLeaf*) G__getstructoffset())->SetUnsigned();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

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

// automatic destructor
typedef TLeaf G__TTLeaf;
static int G__G__Tree_152_0_49(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[] (TLeaf*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TLeaf*) (soff+(sizeof(TLeaf)*i)))->~G__TTLeaf();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TLeaf*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TLeaf*) (soff))->~G__TTLeaf();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TTreeCloner */
static int G__G__Tree_154_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TTreeCloner* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 4:
     //m: 4
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TTreeCloner(
(TTree*) G__int(libp->para[0]), (TTree*) G__int(libp->para[1])
, (Option_t*) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3]));
     } else {
       p = new((void*) gvp) TTreeCloner(
(TTree*) G__int(libp->para[0]), (TTree*) G__int(libp->para[1])
, (Option_t*) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3]));
     }
     break;
   case 3:
     //m: 3
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TTreeCloner(
(TTree*) G__int(libp->para[0]), (TTree*) G__int(libp->para[1])
, (Option_t*) G__int(libp->para[2]));
     } else {
       p = new((void*) gvp) TTreeCloner(
(TTree*) G__int(libp->para[0]), (TTree*) G__int(libp->para[1])
, (Option_t*) G__int(libp->para[2]));
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__TreeLN_TTreeCloner));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_154_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TTreeCloner*) G__getstructoffset())->CloseOutWriteBaskets();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_154_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 104, (long) ((TTreeCloner*) G__getstructoffset())->CollectBranches((TBranch*) G__int(libp->para[0]), (TBranch*) G__int(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_154_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 104, (long) ((TTreeCloner*) G__getstructoffset())->CollectBranches((TObjArray*) G__int(libp->para[0]), (TObjArray*) G__int(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_154_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 104, (long) ((TTreeCloner*) G__getstructoffset())->CollectBranches());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_154_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TTreeCloner*) G__getstructoffset())->CollectBaskets();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_154_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TTreeCloner*) G__getstructoffset())->CopyMemoryBaskets();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_154_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TTreeCloner*) G__getstructoffset())->CopyStreamerInfos();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_154_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TTreeCloner*) G__getstructoffset())->CopyProcessIds();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_154_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) ((const TTreeCloner*) G__getstructoffset())->GetWarning());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_154_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((TTreeCloner*) G__getstructoffset())->Exec());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_154_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((TTreeCloner*) G__getstructoffset())->IsValid());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_154_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((TTreeCloner*) G__getstructoffset())->NeedConversion());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_154_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TTreeCloner*) G__getstructoffset())->SortBaskets();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_154_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TTreeCloner*) G__getstructoffset())->WriteBaskets();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

static int G__G__Tree_154_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TTreeCloner*) G__getstructoffset())->IsA());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_154_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TTreeCloner*) G__getstructoffset())->ShowMembers(*(TMemberInspector*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

// automatic destructor
typedef TTreeCloner G__TTTreeCloner;
static int G__G__Tree_154_0_28(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: 0
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TTreeCloner*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TTreeCloner*) (soff+(sizeof(TTreeCloner)*i)))->~G__TTTreeCloner();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TTreeCloner*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TTreeCloner*) (soff))->~G__TTTreeCloner();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


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

static int G__G__Tree_155_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TBranchClones* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 6:
     //m: 6
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TBranchClones(
(TTree*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (void*) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]), (Int_t) G__int(libp->para[5]));
     } else {
       p = new((void*) gvp) TBranchClones(
(TTree*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (void*) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]), (Int_t) G__int(libp->para[5]));
     }
     break;
   case 5:
     //m: 5
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TBranchClones(
(TTree*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (void*) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]));
     } else {
       p = new((void*) gvp) TBranchClones(
(TTree*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (void*) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]));
     }
     break;
   case 4:
     //m: 4
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TBranchClones(
(TTree*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (void*) G__int(libp->para[2]), (Int_t) G__int(libp->para[3]));
     } else {
       p = new((void*) gvp) TBranchClones(
(TTree*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (void*) G__int(libp->para[2]), (Int_t) G__int(libp->para[3]));
     }
     break;
   case 3:
     //m: 3
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TBranchClones(
(TTree*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (void*) G__int(libp->para[2]));
     } else {
       p = new((void*) gvp) TBranchClones(
(TTree*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (void*) G__int(libp->para[2]));
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__TreeLN_TBranchClones));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_155_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TBranchClones* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 6:
     //m: 6
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TBranchClones(
(TBranch*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (void*) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]), (Int_t) G__int(libp->para[5]));
     } else {
       p = new((void*) gvp) TBranchClones(
(TBranch*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (void*) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]), (Int_t) G__int(libp->para[5]));
     }
     break;
   case 5:
     //m: 5
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TBranchClones(
(TBranch*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (void*) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]));
     } else {
       p = new((void*) gvp) TBranchClones(
(TBranch*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (void*) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]));
     }
     break;
   case 4:
     //m: 4
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TBranchClones(
(TBranch*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (void*) G__int(libp->para[2]), (Int_t) G__int(libp->para[3]));
     } else {
       p = new((void*) gvp) TBranchClones(
(TBranch*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (void*) G__int(libp->para[2]), (Int_t) G__int(libp->para[3]));
     }
     break;
   case 3:
     //m: 3
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TBranchClones(
(TBranch*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (void*) G__int(libp->para[2]));
     } else {
       p = new((void*) gvp) TBranchClones(
(TBranch*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (void*) G__int(libp->para[2]));
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__TreeLN_TBranchClones));
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__Tree_155_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TBranchClones*) G__getstructoffset())->GetList());
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

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

// automatic destructor
typedef TBranchClones G__TTBranchClones;
static int G__G__Tree_155_0_28(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[] (TBranchClones*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TBranchClones*) (soff+(sizeof(TBranchClones)*i)))->~G__TTBranchClones();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TBranchClones*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TBranchClones*) (soff))->~G__TTBranchClones();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


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

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

static int G__G__Tree_191_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TSelector*) G__getstructoffset())->Init((TTree*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_191_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TSelector*) G__getstructoffset())->Begin((TTree*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_191_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TSelector*) G__getstructoffset())->SlaveBegin((TTree*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_191_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) ((const TSelector*) G__getstructoffset())->GetOption());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_191_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letLonglong(result7, 110, (G__int64) ((const TSelector*) G__getstructoffset())->GetStatus());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_191_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      G__letint(result7, 105, (long) ((TSelector*) G__getstructoffset())->GetEntry((Long64_t) G__Longlong(libp->para[0]), (Int_t) G__int(libp->para[1])));
      break;
   case 1:
      G__letint(result7, 105, (long) ((TSelector*) G__getstructoffset())->GetEntry((Long64_t) G__Longlong(libp->para[0])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_191_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((TSelector*) G__getstructoffset())->ProcessCut((Long64_t) G__Longlong(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_191_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TSelector*) G__getstructoffset())->ProcessFill((Long64_t) G__Longlong(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_191_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((TSelector*) G__getstructoffset())->Process((Long64_t) G__Longlong(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_191_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TSelector*) G__getstructoffset())->SetOption((const char*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_191_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TSelector*) G__getstructoffset())->SetObject((TObject*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_191_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TSelector*) G__getstructoffset())->SetInputList((TList*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_191_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TSelector*) G__getstructoffset())->SetStatus((Long64_t) G__Longlong(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_191_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TSelector*) G__getstructoffset())->GetOutputList());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_191_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TSelector*) G__getstructoffset())->SlaveTerminate();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_191_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TSelector*) G__getstructoffset())->Terminate();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

static int G__G__Tree_191_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TSelector::GetSelector((const char*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_191_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) TSelector::IsStandardDraw((const char*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

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

// automatic destructor
typedef TSelector G__TTSelector;
static int G__G__Tree_191_0_38(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[] (TSelector*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TSelector*) (soff+(sizeof(TSelector)*i)))->~G__TTSelector();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TSelector*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TSelector*) (soff))->~G__TTSelector();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TVirtualIndex */
static int G__G__Tree_193_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((TVirtualIndex*) G__getstructoffset())->Append((TVirtualIndex*) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TVirtualIndex*) G__getstructoffset())->Append((TVirtualIndex*) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_193_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TVirtualIndex*) G__getstructoffset())->GetEntryNumberFriend((TTree*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_193_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letLonglong(result7, 110, (G__int64) ((const TVirtualIndex*) G__getstructoffset())->GetEntryNumberWithIndex((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_193_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letLonglong(result7, 110, (G__int64) ((const TVirtualIndex*) G__getstructoffset())->GetEntryNumberWithBestIndex((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_193_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) ((const TVirtualIndex*) G__getstructoffset())->GetMajorName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_193_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) ((const TVirtualIndex*) G__getstructoffset())->GetMinorName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_193_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letLonglong(result7, 110, (G__int64) ((const TVirtualIndex*) G__getstructoffset())->GetN());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_193_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TVirtualIndex*) G__getstructoffset())->GetTree());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_193_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVirtualIndex*) G__getstructoffset())->UpdateFormulaLeaves((TTree*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_193_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVirtualIndex*) G__getstructoffset())->SetTree((TTree*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

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

// automatic destructor
typedef TVirtualIndex G__TTVirtualIndex;
static int G__G__Tree_193_0_24(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[] (TVirtualIndex*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TVirtualIndex*) (soff+(sizeof(TVirtualIndex)*i)))->~G__TTVirtualIndex();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TVirtualIndex*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TVirtualIndex*) (soff))->~G__TTVirtualIndex();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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


/* TVirtualTreePlayer */
static int G__G__Tree_194_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TVirtualTreePlayer*) G__getstructoffset())->BuildIndex((TTree*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_194_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 4:
      G__letint(result7, 85, (long) ((TVirtualTreePlayer*) G__getstructoffset())->CopyTree((const char*) G__int(libp->para[0]), (Option_t*) G__int(libp->para[1])
, (Long64_t) G__Longlong(libp->para[2]), (Long64_t) G__Longlong(libp->para[3])));
      break;
   case 3:
      G__letint(result7, 85, (long) ((TVirtualTreePlayer*) G__getstructoffset())->CopyTree((const char*) G__int(libp->para[0]), (Option_t*) G__int(libp->para[1])
, (Long64_t) G__Longlong(libp->para[2])));
      break;
   case 2:
      G__letint(result7, 85, (long) ((TVirtualTreePlayer*) G__getstructoffset())->CopyTree((const char*) G__int(libp->para[0]), (Option_t*) G__int(libp->para[1])));
      break;
   case 1:
      G__letint(result7, 85, (long) ((TVirtualTreePlayer*) G__getstructoffset())->CopyTree((const char*) G__int(libp->para[0])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_194_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letLonglong(result7, 110, (G__int64) ((TVirtualTreePlayer*) G__getstructoffset())->DrawScript((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]), (Option_t*) G__int(libp->para[3])
, (Long64_t) G__Longlong(libp->para[4]), (Long64_t) G__Longlong(libp->para[5])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_194_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letLonglong(result7, 110, (G__int64) ((TVirtualTreePlayer*) G__getstructoffset())->DrawSelect((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Option_t*) G__int(libp->para[2]), (Long64_t) G__Longlong(libp->para[3])
, (Long64_t) G__Longlong(libp->para[4])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_194_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TVirtualTreePlayer*) G__getstructoffset())->Fit(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]), (Option_t*) G__int(libp->para[3])
, (Option_t*) G__int(libp->para[4]), (Long64_t) G__Longlong(libp->para[5])
, (Long64_t) G__Longlong(libp->para[6])));
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__Tree_194_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TVirtualTreePlayer*) G__getstructoffset())->GetHistogram());
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__Tree_194_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letLonglong(result7, 110, (G__int64) ((TVirtualTreePlayer*) G__getstructoffset())->GetEntries((const char*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_194_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letLonglong(result7, 110, (G__int64) ((const TVirtualTreePlayer*) G__getstructoffset())->GetSelectedRows());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_194_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TVirtualTreePlayer*) G__getstructoffset())->GetSelect());
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__Tree_194_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TVirtualTreePlayer*) G__getstructoffset())->GetVar1());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_194_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TVirtualTreePlayer*) G__getstructoffset())->GetVar2());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_194_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TVirtualTreePlayer*) G__getstructoffset())->GetVar3());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_194_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TVirtualTreePlayer*) G__getstructoffset())->GetVar4());
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__Tree_194_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 68, (long) ((const TVirtualTreePlayer*) G__getstructoffset())->GetV1());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_194_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 68, (long) ((const TVirtualTreePlayer*) G__getstructoffset())->GetV2());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_194_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 68, (long) ((const TVirtualTreePlayer*) G__getstructoffset())->GetV3());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_194_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 68, (long) ((const TVirtualTreePlayer*) G__getstructoffset())->GetV4());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_194_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 68, (long) ((const TVirtualTreePlayer*) G__getstructoffset())->GetW());
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

static int G__G__Tree_194_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 5:
      G__letint(result7, 105, (long) ((TVirtualTreePlayer*) G__getstructoffset())->MakeProxy((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]), (const char*) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4])));
      break;
   case 4:
      G__letint(result7, 105, (long) ((TVirtualTreePlayer*) G__getstructoffset())->MakeProxy((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]), (const char*) G__int(libp->para[3])));
      break;
   case 3:
      G__letint(result7, 105, (long) ((TVirtualTreePlayer*) G__getstructoffset())->MakeProxy((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2])));
      break;
   case 2:
      G__letint(result7, 105, (long) ((TVirtualTreePlayer*) G__getstructoffset())->MakeProxy((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])));
      break;
   case 1:
      G__letint(result7, 105, (long) ((TVirtualTreePlayer*) G__getstructoffset())->MakeProxy((const char*) G__int(libp->para[0])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_194_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 5:
      G__letint(result7, 85, (long) ((TVirtualTreePlayer*) G__getstructoffset())->Principal((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Option_t*) G__int(libp->para[2]), (Long64_t) G__Longlong(libp->para[3])
, (Long64_t) G__Longlong(libp->para[4])));
      break;
   case 4:
      G__letint(result7, 85, (long) ((TVirtualTreePlayer*) G__getstructoffset())->Principal((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Option_t*) G__int(libp->para[2]), (Long64_t) G__Longlong(libp->para[3])));
      break;
   case 3:
      G__letint(result7, 85, (long) ((TVirtualTreePlayer*) G__getstructoffset())->Principal((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Option_t*) G__int(libp->para[2])));
      break;
   case 2:
      G__letint(result7, 85, (long) ((TVirtualTreePlayer*) G__getstructoffset())->Principal((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])));
      break;
   case 1:
      G__letint(result7, 85, (long) ((TVirtualTreePlayer*) G__getstructoffset())->Principal((const char*) G__int(libp->para[0])));
      break;
   case 0:
      G__letint(result7, 85, (long) ((TVirtualTreePlayer*) G__getstructoffset())->Principal());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_194_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 4:
      G__letLonglong(result7, 110, (G__int64) ((TVirtualTreePlayer*) G__getstructoffset())->Process((const char*) G__int(libp->para[0]), (Option_t*) G__int(libp->para[1])
, (Long64_t) G__Longlong(libp->para[2]), (Long64_t) G__Longlong(libp->para[3])));
      break;
   case 3:
      G__letLonglong(result7, 110, (G__int64) ((TVirtualTreePlayer*) G__getstructoffset())->Process((const char*) G__int(libp->para[0]), (Option_t*) G__int(libp->para[1])
, (Long64_t) G__Longlong(libp->para[2])));
      break;
   case 2:
      G__letLonglong(result7, 110, (G__int64) ((TVirtualTreePlayer*) G__getstructoffset())->Process((const char*) G__int(libp->para[0]), (Option_t*) G__int(libp->para[1])));
      break;
   case 1:
      G__letLonglong(result7, 110, (G__int64) ((TVirtualTreePlayer*) G__getstructoffset())->Process((const char*) G__int(libp->para[0])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_194_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 4:
      G__letLonglong(result7, 110, (G__int64) ((TVirtualTreePlayer*) G__getstructoffset())->Process((TSelector*) G__int(libp->para[0]), (Option_t*) G__int(libp->para[1])
, (Long64_t) G__Longlong(libp->para[2]), (Long64_t) G__Longlong(libp->para[3])));
      break;
   case 3:
      G__letLonglong(result7, 110, (G__int64) ((TVirtualTreePlayer*) G__getstructoffset())->Process((TSelector*) G__int(libp->para[0]), (Option_t*) G__int(libp->para[1])
, (Long64_t) G__Longlong(libp->para[2])));
      break;
   case 2:
      G__letLonglong(result7, 110, (G__int64) ((TVirtualTreePlayer*) G__getstructoffset())->Process((TSelector*) G__int(libp->para[0]), (Option_t*) G__int(libp->para[1])));
      break;
   case 1:
      G__letLonglong(result7, 110, (G__int64) ((TVirtualTreePlayer*) G__getstructoffset())->Process((TSelector*) G__int(libp->para[0])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_194_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letLonglong(result7, 110, (G__int64) ((TVirtualTreePlayer*) G__getstructoffset())->Scan((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Option_t*) G__int(libp->para[2]), (Long64_t) G__Longlong(libp->para[3])
, (Long64_t) G__Longlong(libp->para[4])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_194_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TVirtualTreePlayer*) G__getstructoffset())->Query((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Option_t*) G__int(libp->para[2]), (Long64_t) G__Longlong(libp->para[3])
, (Long64_t) G__Longlong(libp->para[4])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_194_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVirtualTreePlayer*) G__getstructoffset())->SetEstimate((Long64_t) G__Longlong(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_194_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVirtualTreePlayer*) G__getstructoffset())->SetTree((TTree*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_194_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVirtualTreePlayer*) G__getstructoffset())->StartViewer((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_194_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TVirtualTreePlayer*) G__getstructoffset())->UnbinnedFit((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]), (Option_t*) G__int(libp->para[3])
, (Long64_t) G__Longlong(libp->para[4]), (Long64_t) G__Longlong(libp->para[5])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_194_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVirtualTreePlayer*) G__getstructoffset())->UpdateFormulaLeaves();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__Tree_194_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TVirtualTreePlayer::TreePlayer((TTree*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_194_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TVirtualTreePlayer::SetPlayer((const char*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

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

// automatic destructor
typedef TVirtualTreePlayer G__TTVirtualTreePlayer;
static int G__G__Tree_194_0_52(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[] (TVirtualTreePlayer*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TVirtualTreePlayer*) (soff+(sizeof(TVirtualTreePlayer)*i)))->~G__TTVirtualTreePlayer();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TVirtualTreePlayer*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TVirtualTreePlayer*) (soff))->~G__TTVirtualTreePlayer();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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


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

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

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

static int G__G__Tree_196_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEventList*) G__getstructoffset())->Add((TEventList*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_196_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((TEventList*) G__getstructoffset())->Contains((Long64_t) G__Longlong(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_196_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((TEventList*) G__getstructoffset())->ContainsRange((Long64_t) G__Longlong(libp->para[0]), (Long64_t) G__Longlong(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_196_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEventList*) G__getstructoffset())->DirectoryAutoAdd((TDirectory*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_196_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEventList*) G__getstructoffset())->Enter((Long64_t) G__Longlong(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_196_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TEventList*) G__getstructoffset())->GetDirectory());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_196_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letLonglong(result7, 110, (G__int64) ((const TEventList*) G__getstructoffset())->GetEntry((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_196_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TEventList*) G__getstructoffset())->GetIndex((Long64_t) G__Longlong(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_196_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 78, (long) ((const TEventList*) G__getstructoffset())->GetList());
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

static int G__G__Tree_196_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEventList*) G__getstructoffset())->Intersect((TEventList*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_196_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TEventList*) G__getstructoffset())->Merge((TCollection*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

static int G__G__Tree_196_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEventList*) G__getstructoffset())->SetDirectory((TDirectory*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__Tree_196_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEventList*) G__getstructoffset())->Sort();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_196_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEventList*) G__getstructoffset())->Subtract((TEventList*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

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

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

// automatic destructor
typedef TEventList G__TTEventList;
static int G__G__Tree_196_0_41(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[] (TEventList*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TEventList*) (soff+(sizeof(TEventList)*i)))->~G__TTEventList();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TEventList*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TEventList*) (soff))->~G__TTEventList();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


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

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

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

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

static int G__G__Tree_197_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TEntryList* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TEntryList((TTree*) G__int(libp->para[0]));
   } else {
     p = new((void*) gvp) TEntryList((TTree*) G__int(libp->para[0]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__TreeLN_TEntryList));
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__Tree_197_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEntryList*) G__getstructoffset())->Add((TEntryList*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_197_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      G__letint(result7, 105, (long) ((TEntryList*) G__getstructoffset())->Contains((Long64_t) G__Longlong(libp->para[0]), (TTree*) G__int(libp->para[1])));
      break;
   case 1:
      G__letint(result7, 105, (long) ((TEntryList*) G__getstructoffset())->Contains((Long64_t) G__Longlong(libp->para[0])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_197_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEntryList*) G__getstructoffset())->DirectoryAutoAdd((TDirectory*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_197_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      G__letint(result7, 103, (long) ((TEntryList*) G__getstructoffset())->Enter((Long64_t) G__Longlong(libp->para[0]), (TTree*) G__int(libp->para[1])));
      break;
   case 1:
      G__letint(result7, 103, (long) ((TEntryList*) G__getstructoffset())->Enter((Long64_t) G__Longlong(libp->para[0])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_197_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TEntryList*) G__getstructoffset())->GetCurrentList());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_197_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      G__letint(result7, 85, (long) ((TEntryList*) G__getstructoffset())->GetEntryList((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Option_t*) G__int(libp->para[2])));
      break;
   case 2:
      G__letint(result7, 85, (long) ((TEntryList*) G__getstructoffset())->GetEntryList((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_197_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letLonglong(result7, 110, (G__int64) ((TEntryList*) G__getstructoffset())->GetEntry((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_197_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letLonglong(result7, 110, (G__int64) ((TEntryList*) G__getstructoffset())->GetEntryAndTree((Int_t) G__int(libp->para[0]), *(Int_t*) G__Intref(&libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_197_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letLonglong(result7, 110, (G__int64) ((const TEntryList*) G__getstructoffset())->GetEntriesToProcess());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_197_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TEntryList*) G__getstructoffset())->GetLists());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_197_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TEntryList*) G__getstructoffset())->GetDirectory());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_197_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letLonglong(result7, 110, (G__int64) ((const TEntryList*) G__getstructoffset())->GetN());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_197_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) ((const TEntryList*) G__getstructoffset())->GetTreeName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_197_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) ((const TEntryList*) G__getstructoffset())->GetFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

static int G__G__Tree_197_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TEntryList*) G__getstructoffset())->Merge((TCollection*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_197_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letLonglong(result7, 110, (G__int64) ((TEntryList*) G__getstructoffset())->Next());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_197_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEntryList*) G__getstructoffset())->OptimizeStorage();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_197_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      G__letint(result7, 103, (long) ((TEntryList*) G__getstructoffset())->Remove((Long64_t) G__Longlong(libp->para[0]), (TTree*) G__int(libp->para[1])));
      break;
   case 1:
      G__letint(result7, 103, (long) ((TEntryList*) G__getstructoffset())->Remove((Long64_t) G__Longlong(libp->para[0])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_197_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEntryList*) G__getstructoffset())->Reset();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_197_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEntryList*) G__getstructoffset())->SetDirectory((TDirectory*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_197_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEntryList*) G__getstructoffset())->SetEntriesToProcess((Long64_t) G__Longlong(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_197_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEntryList*) G__getstructoffset())->SetShift((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_197_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEntryList*) G__getstructoffset())->SetTree((TTree*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_197_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEntryList*) G__getstructoffset())->SetTree((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_197_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEntryList*) G__getstructoffset())->SetTreeName((const char*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_197_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEntryList*) G__getstructoffset())->SetFileName((const char*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_197_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEntryList*) G__getstructoffset())->SetTreeNumber((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__Tree_197_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEntryList*) G__getstructoffset())->Subtract((TEntryList*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

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

// automatic destructor
typedef TEntryList G__TTEntryList;
static int G__G__Tree_197_0_52(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[] (TEntryList*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TEntryList*) (soff+(sizeof(TEntryList)*i)))->~G__TTEntryList();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TEntryList*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TEntryList*) (soff))->~G__TTEntryList();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


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

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

static int G__G__Tree_198_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TFriendElement* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 3
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TFriendElement(
(TTree*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (TFile*) G__int(libp->para[2]));
   } else {
     p = new((void*) gvp) TFriendElement(
(TTree*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (TFile*) G__int(libp->para[2]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__TreeLN_TFriendElement));
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

static int G__G__Tree_198_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TFriendElement*) G__getstructoffset())->GetParentTree());
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__Tree_198_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) ((const TFriendElement*) G__getstructoffset())->GetTreeName());
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

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

// automatic destructor
typedef TFriendElement G__TTFriendElement;
static int G__G__Tree_198_0_26(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[] (TFriendElement*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TFriendElement*) (soff+(sizeof(TFriendElement)*i)))->~G__TTFriendElement();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TFriendElement*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TFriendElement*) (soff))->~G__TTFriendElement();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


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

static int G__G__Tree_199_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TCut* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TCut((const char*) G__int(libp->para[0]));
   } else {
     p = new((void*) gvp) TCut((const char*) G__int(libp->para[0]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__TreeLN_TCut));
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

static int G__G__Tree_199_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TCut& obj = ((TCut*) G__getstructoffset())->operator+=((const char*) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

static int G__G__Tree_199_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TCut*) G__getstructoffset())->operator==((const char*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_199_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TCut*) G__getstructoffset())->operator==(*(TCut*) libp->para[0].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_199_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TCut*) G__getstructoffset())->operator!=((const char*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_199_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TCut*) G__getstructoffset())->operator!=(*(TCut*) libp->para[0].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_199_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) ((const TCut*) G__getstructoffset())->operator const char*());
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

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

// automatic destructor
typedef TCut G__TTCut;
static int G__G__Tree_199_0_32(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[] (TCut*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TCut*) (soff+(sizeof(TCut)*i)))->~G__TTCut();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TCut*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TCut*) (soff))->~G__TTCut();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


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

static int G__G__Tree_200_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TBranchRef* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TBranchRef((TTree*) G__int(libp->para[0]));
   } else {
     p = new((void*) gvp) TBranchRef((TTree*) G__int(libp->para[0]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__TreeLN_TBranchRef));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_200_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TBranchRef*) G__getstructoffset())->GetRefTable());
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__Tree_200_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TBranchRef*) G__getstructoffset())->SetReadEntry((Long64_t) G__Longlong(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

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

// automatic destructor
typedef TBranchRef G__TTBranchRef;
static int G__G__Tree_200_0_25(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[] (TBranchRef*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TBranchRef*) (soff+(sizeof(TBranchRef)*i)))->~G__TTBranchRef();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TBranchRef*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TBranchRef*) (soff))->~G__TTBranchRef();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TTreeFriendLeafIter */
static int G__G__Tree_206_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TTreeFriendLeafIter* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 2:
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TTreeFriendLeafIter((TTree*) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) TTreeFriendLeafIter((TTree*) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1]));
     }
     break;
   case 1:
     //m: 1
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TTreeFriendLeafIter((TTree*) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) TTreeFriendLeafIter((TTree*) G__int(libp->para[0]));
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__TreeLN_TTreeFriendLeafIter));
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

static int G__G__Tree_206_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TTreeFriendLeafIter*) G__getstructoffset())->operator!=(*(TTreeFriendLeafIter*) libp->para[0].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

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

// automatic destructor
typedef TTreeFriendLeafIter G__TTTreeFriendLeafIter;
static int G__G__Tree_206_0_25(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: 0
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TTreeFriendLeafIter*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TTreeFriendLeafIter*) (soff+(sizeof(TTreeFriendLeafIter)*i)))->~G__TTTreeFriendLeafIter();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TTreeFriendLeafIter*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TTreeFriendLeafIter*) (soff))->~G__TTTreeFriendLeafIter();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


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

static int G__G__Tree_211_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TBranchObject* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 8:
     //m: 8
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TBranchObject(
(TBranch*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]), (void*) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]), (Int_t) G__int(libp->para[5])
, (Int_t) G__int(libp->para[6]), (Bool_t) G__int(libp->para[7]));
     } else {
       p = new((void*) gvp) TBranchObject(
(TBranch*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]), (void*) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]), (Int_t) G__int(libp->para[5])
, (Int_t) G__int(libp->para[6]), (Bool_t) G__int(libp->para[7]));
     }
     break;
   case 7:
     //m: 7
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TBranchObject(
(TBranch*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]), (void*) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]), (Int_t) G__int(libp->para[5])
, (Int_t) G__int(libp->para[6]));
     } else {
       p = new((void*) gvp) TBranchObject(
(TBranch*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]), (void*) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]), (Int_t) G__int(libp->para[5])
, (Int_t) G__int(libp->para[6]));
     }
     break;
   case 6:
     //m: 6
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TBranchObject(
(TBranch*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]), (void*) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]), (Int_t) G__int(libp->para[5]));
     } else {
       p = new((void*) gvp) TBranchObject(
(TBranch*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]), (void*) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]), (Int_t) G__int(libp->para[5]));
     }
     break;
   case 5:
     //m: 5
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TBranchObject(
(TBranch*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]), (void*) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]));
     } else {
       p = new((void*) gvp) TBranchObject(
(TBranch*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]), (void*) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]));
     }
     break;
   case 4:
     //m: 4
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TBranchObject(
(TBranch*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]), (void*) G__int(libp->para[3]));
     } else {
       p = new((void*) gvp) TBranchObject(
(TBranch*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]), (void*) G__int(libp->para[3]));
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__TreeLN_TBranchObject));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_211_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TBranchObject* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 8:
     //m: 8
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TBranchObject(
(TTree*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]), (void*) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]), (Int_t) G__int(libp->para[5])
, (Int_t) G__int(libp->para[6]), (Bool_t) G__int(libp->para[7]));
     } else {
       p = new((void*) gvp) TBranchObject(
(TTree*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]), (void*) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]), (Int_t) G__int(libp->para[5])
, (Int_t) G__int(libp->para[6]), (Bool_t) G__int(libp->para[7]));
     }
     break;
   case 7:
     //m: 7
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TBranchObject(
(TTree*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]), (void*) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]), (Int_t) G__int(libp->para[5])
, (Int_t) G__int(libp->para[6]));
     } else {
       p = new((void*) gvp) TBranchObject(
(TTree*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]), (void*) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]), (Int_t) G__int(libp->para[5])
, (Int_t) G__int(libp->para[6]));
     }
     break;
   case 6:
     //m: 6
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TBranchObject(
(TTree*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]), (void*) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]), (Int_t) G__int(libp->para[5]));
     } else {
       p = new((void*) gvp) TBranchObject(
(TTree*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]), (void*) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]), (Int_t) G__int(libp->para[5]));
     }
     break;
   case 5:
     //m: 5
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TBranchObject(
(TTree*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]), (void*) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]));
     } else {
       p = new((void*) gvp) TBranchObject(
(TTree*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]), (void*) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]));
     }
     break;
   case 4:
     //m: 4
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TBranchObject(
(TTree*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]), (void*) G__int(libp->para[3]));
     } else {
       p = new((void*) gvp) TBranchObject(
(TTree*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]), (void*) G__int(libp->para[3]));
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__TreeLN_TBranchObject));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_211_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) ((TBranchObject*) G__getstructoffset())->GetObjClassName());
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

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

// automatic destructor
typedef TBranchObject G__TTBranchObject;
static int G__G__Tree_211_0_31(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[] (TBranchObject*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TBranchObject*) (soff+(sizeof(TBranchObject)*i)))->~G__TTBranchObject();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TBranchObject*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TBranchObject*) (soff))->~G__TTBranchObject();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


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

static int G__G__Tree_225_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TIndArray*) G__getstructoffset())->Reserve((UInt_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_225_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 104, (long) ((TIndArray*) G__getstructoffset())->GetCapacity());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_225_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 104, (long) ((TIndArray*) G__getstructoffset())->GetNumItems());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_225_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TIndArray*) G__getstructoffset())->SetNumItems((UInt_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_225_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const UChar_t& obj = ((TIndArray*) G__getstructoffset())->At((Int_t) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         G__letint(result7, 'b', (long)obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_225_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TIndArray*) G__getstructoffset())->Clear();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

// automatic destructor
typedef TIndArray G__TTIndArray;
static int G__G__Tree_225_0_9(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: 0
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TIndArray*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TIndArray*) (soff+(sizeof(TIndArray)*i)))->~G__TTIndArray();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TIndArray*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TIndArray*) (soff))->~G__TTIndArray();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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


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

static int G__G__Tree_226_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TBranchSTL* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 5
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TBranchSTL(
(TTree*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (TVirtualCollectionProxy*) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]));
   } else {
     p = new((void*) gvp) TBranchSTL(
(TTree*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (TVirtualCollectionProxy*) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__TreeLN_TBranchSTL));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_226_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TBranchSTL* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 7
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TBranchSTL(
(TBranch*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (TVirtualCollectionProxy*) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]), (TStreamerInfo*) G__int(libp->para[5])
, (Int_t) G__int(libp->para[6]));
   } else {
     p = new((void*) gvp) TBranchSTL(
(TBranch*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (TVirtualCollectionProxy*) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]), (TStreamerInfo*) G__int(libp->para[5])
, (Int_t) G__int(libp->para[6]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__TreeLN_TBranchSTL));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_226_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TBranchSTL*) G__getstructoffset())->GetInfo());
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

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

// automatic destructor
typedef TBranchSTL G__TTBranchSTL;
static int G__G__Tree_226_0_26(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[] (TBranchSTL*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TBranchSTL*) (soff+(sizeof(TBranchSTL)*i)))->~G__TTBranchSTL();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TBranchSTL*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TBranchSTL*) (soff))->~G__TTBranchSTL();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


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

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

static int G__G__Tree_234_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TChainElement*) G__getstructoffset())->CreatePackets();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_234_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 89, (long) ((const TChainElement*) G__getstructoffset())->GetBaddress());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_234_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) ((const TChainElement*) G__getstructoffset())->GetBaddressClassName());
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__Tree_234_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 104, (long) ((const TChainElement*) G__getstructoffset())->GetBaddressType());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_234_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TChainElement*) G__getstructoffset())->GetBranchPtr());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_234_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letLonglong(result7, 110, (G__int64) ((const TChainElement*) G__getstructoffset())->GetEntries());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_234_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) ((const TChainElement*) G__getstructoffset())->GetPackets());
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

static int G__G__Tree_234_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((TChainElement*) G__getstructoffset())->HasBeenLookedUp());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_234_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TChainElement*) G__getstructoffset())->SetBaddress((void*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_234_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TChainElement*) G__getstructoffset())->SetBaddressClassName((const char*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_234_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TChainElement*) G__getstructoffset())->SetBaddressIsPtr((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_234_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TChainElement*) G__getstructoffset())->SetBaddressType((UInt_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_234_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TChainElement*) G__getstructoffset())->SetBranchPtr((TBranch**) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__Tree_234_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TChainElement*) G__getstructoffset())->SetNumberEntries((Long64_t) G__Longlong(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__Tree_234_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TChainElement*) G__getstructoffset())->SetStatus((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

static int G__G__Tree_234_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TChainElement::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__G__Tree_234_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   TChainElement* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new TChainElement(*(TChainElement*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__TreeLN_TChainElement));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TChainElement G__TTChainElement;
static int G__G__Tree_234_0_37(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[] (TChainElement*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TChainElement*) (soff+(sizeof(TChainElement)*i)))->~G__TTChainElement();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TChainElement*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TChainElement*) (soff))->~G__TTChainElement();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__G__Tree_234_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TChainElement* dest = (TChainElement*) G__getstructoffset();
   *dest = *(TChainElement*) libp->para[0].ref;
   const TChainElement& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TChain */
static int G__G__Tree_236_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TChain* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TChain[n];
     } else {
       p = new((void*) gvp) TChain[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TChain;
     } else {
       p = new((void*) gvp) TChain;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__TreeLN_TChain));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_236_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TChain* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 2:
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TChain((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) TChain((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1]));
     }
     break;
   case 1:
     //m: 1
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TChain((const char*) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) TChain((const char*) G__int(libp->para[0]));
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__TreeLN_TChain));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_236_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TChain*) G__getstructoffset())->Add((TChain*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_236_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      G__letint(result7, 105, (long) ((TChain*) G__getstructoffset())->Add((const char*) G__int(libp->para[0]), (Long64_t) G__Longlong(libp->para[1])));
      break;
   case 1:
      G__letint(result7, 105, (long) ((TChain*) G__getstructoffset())->Add((const char*) G__int(libp->para[0])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_236_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      G__letint(result7, 105, (long) ((TChain*) G__getstructoffset())->AddFile((const char*) G__int(libp->para[0]), (Long64_t) G__Longlong(libp->para[1])
, (const char*) G__int(libp->para[2])));
      break;
   case 2:
      G__letint(result7, 105, (long) ((TChain*) G__getstructoffset())->AddFile((const char*) G__int(libp->para[0]), (Long64_t) G__Longlong(libp->para[1])));
      break;
   case 1:
      G__letint(result7, 105, (long) ((TChain*) G__getstructoffset())->AddFile((const char*) G__int(libp->para[0])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_236_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      G__letint(result7, 105, (long) ((TChain*) G__getstructoffset())->AddFileInfoList((TCollection*) G__int(libp->para[0]), (Long64_t) G__Longlong(libp->para[1])));
      break;
   case 1:
      G__letint(result7, 105, (long) ((TChain*) G__getstructoffset())->AddFileInfoList((TCollection*) G__int(libp->para[0])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_236_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TChain*) G__getstructoffset())->CanDeleteRefs((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TChain*) G__getstructoffset())->CanDeleteRefs();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_236_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TChain*) G__getstructoffset())->CreatePackets();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_236_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TChain*) G__getstructoffset())->GetNtrees());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_236_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TChain*) G__getstructoffset())->GetFile());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_236_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TChain*) G__getstructoffset())->GetListOfFiles());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_236_0_42(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TChain*) G__getstructoffset())->GetStatus());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_236_0_45(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 78, (long) ((const TChain*) G__getstructoffset())->GetTreeOffset());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_236_0_46(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TChain*) G__getstructoffset())->GetTreeOffsetLen());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_236_0_50(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TChain*) G__getstructoffset())->Lookup((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TChain*) G__getstructoffset())->Lookup();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_236_0_51(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      ((TChain*) G__getstructoffset())->Loop((Option_t*) G__int(libp->para[0]), (Long64_t) G__Longlong(libp->para[1])
, (Long64_t) G__Longlong(libp->para[2]));
      G__setnull(result7);
      break;
   case 2:
      ((TChain*) G__getstructoffset())->Loop((Option_t*) G__int(libp->para[0]), (Long64_t) G__Longlong(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TChain*) G__getstructoffset())->Loop((Option_t*) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TChain*) G__getstructoffset())->Loop();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_236_0_53(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      G__letLonglong(result7, 110, (G__int64) ((TChain*) G__getstructoffset())->Merge((const char*) G__int(libp->para[0]), (Option_t*) G__int(libp->para[1])));
      break;
   case 1:
      G__letLonglong(result7, 110, (G__int64) ((TChain*) G__getstructoffset())->Merge((const char*) G__int(libp->para[0])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_236_0_55(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      G__letLonglong(result7, 110, (G__int64) ((TChain*) G__getstructoffset())->Merge((TFile*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Option_t*) G__int(libp->para[2])));
      break;
   case 2:
      G__letLonglong(result7, 110, (G__int64) ((TChain*) G__getstructoffset())->Merge((TFile*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_236_0_63(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TChain*) G__getstructoffset())->SetAutoDelete((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TChain*) G__getstructoffset())->SetAutoDelete();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_236_0_64(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      G__letint(result7, 105, (long) ((TChain*) G__getstructoffset())->SetBranchAddress((const char*) G__int(libp->para[0]), (void*) G__int(libp->para[1])
, (TBranch**) G__int(libp->para[2])));
      break;
   case 2:
      G__letint(result7, 105, (long) ((TChain*) G__getstructoffset())->SetBranchAddress((const char*) G__int(libp->para[0]), (void*) G__int(libp->para[1])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_236_0_70(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((TChain*) G__getstructoffset())->SetEntryListFile((const char*) G__int(libp->para[0]), (Option_t*) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TChain*) G__getstructoffset())->SetEntryListFile((const char*) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TChain*) G__getstructoffset())->SetEntryListFile();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_236_0_73(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TChain*) G__getstructoffset())->SetPacketSize((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TChain*) G__getstructoffset())->SetPacketSize();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_236_0_74(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      ((TChain*) G__getstructoffset())->SetProof((Bool_t) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1])
, (Bool_t) G__int(libp->para[2]));
      G__setnull(result7);
      break;
   case 2:
      ((TChain*) G__getstructoffset())->SetProof((Bool_t) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TChain*) G__getstructoffset())->SetProof((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TChain*) G__getstructoffset())->SetProof();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_236_0_76(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((TChain*) G__getstructoffset())->UseCache((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TChain*) G__getstructoffset())->UseCache((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TChain*) G__getstructoffset())->UseCache();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_236_0_77(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TChain::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_236_0_78(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TChain::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_236_0_79(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TChain::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_236_0_80(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TChain::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_236_0_84(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TChain*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_236_0_85(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TChain::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_236_0_86(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TChain::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_236_0_87(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TChain::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_236_0_88(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TChain::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TChain G__TTChain;
static int G__G__Tree_236_0_89(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[] (TChain*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TChain*) (soff+(sizeof(TChain)*i)))->~G__TTChain();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TChain*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TChain*) (soff))->~G__TTChain();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TEntryListBlock */
static int G__G__Tree_238_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TEntryListBlock* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEntryListBlock[n];
     } else {
       p = new((void*) gvp) TEntryListBlock[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEntryListBlock;
     } else {
       p = new((void*) gvp) TEntryListBlock;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__TreeLN_TEntryListBlock));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_238_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TEntryListBlock* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TEntryListBlock(*(TEntryListBlock*) libp->para[0].ref);
   } else {
     p = new((void*) gvp) TEntryListBlock(*(TEntryListBlock*) libp->para[0].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__TreeLN_TEntryListBlock));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_238_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((TEntryListBlock*) G__getstructoffset())->Enter((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_238_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((TEntryListBlock*) G__getstructoffset())->Remove((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_238_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TEntryListBlock*) G__getstructoffset())->Contains((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_238_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEntryListBlock*) G__getstructoffset())->OptimizeStorage();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_238_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TEntryListBlock*) G__getstructoffset())->Merge((TEntryListBlock*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_238_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TEntryListBlock*) G__getstructoffset())->Next());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_238_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TEntryListBlock*) G__getstructoffset())->GetEntry((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_238_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEntryListBlock*) G__getstructoffset())->ResetIndices();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_238_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TEntryListBlock*) G__getstructoffset())->GetType());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_238_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TEntryListBlock*) G__getstructoffset())->GetNPassed());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_238_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const TEntryListBlock*) G__getstructoffset())->PrintWithShift((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_238_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TEntryListBlock::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_238_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEntryListBlock::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_238_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TEntryListBlock::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_238_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TEntryListBlock::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_238_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEntryListBlock*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_238_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEntryListBlock::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_238_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEntryListBlock::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_238_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEntryListBlock::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_238_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEntryListBlock::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TEntryListBlock G__TTEntryListBlock;
static int G__G__Tree_238_0_28(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[] (TEntryListBlock*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TEntryListBlock*) (soff+(sizeof(TEntryListBlock)*i)))->~G__TTEntryListBlock();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TEntryListBlock*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TEntryListBlock*) (soff))->~G__TTEntryListBlock();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__G__Tree_238_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TEntryListBlock* dest = (TEntryListBlock*) G__getstructoffset();
   *dest = *(TEntryListBlock*) libp->para[0].ref;
   const TEntryListBlock& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TEntryListFromFile */
static int G__G__Tree_241_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TEntryListFromFile* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEntryListFromFile[n];
     } else {
       p = new((void*) gvp) TEntryListFromFile[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEntryListFromFile;
     } else {
       p = new((void*) gvp) TEntryListFromFile;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__TreeLN_TEntryListFromFile));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_241_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TEntryListFromFile* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 3
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TEntryListFromFile(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]));
   } else {
     p = new((void*) gvp) TEntryListFromFile(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__TreeLN_TEntryListFromFile));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_241_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letLonglong(result7, 110, (G__int64) ((TEntryListFromFile*) G__getstructoffset())->GetEntries());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_241_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letLonglong(result7, 110, (G__int64) ((const TEntryListFromFile*) G__getstructoffset())->GetEntriesFast());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_241_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TEntryListFromFile*) G__getstructoffset())->LoadList((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_241_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEntryListFromFile*) G__getstructoffset())->SetFileNames((TObjArray*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_241_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEntryListFromFile*) G__getstructoffset())->SetNFiles((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_241_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TEntryListFromFile::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_241_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEntryListFromFile::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_241_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TEntryListFromFile::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_241_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TEntryListFromFile::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_241_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEntryListFromFile*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_241_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEntryListFromFile::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_241_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEntryListFromFile::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_241_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEntryListFromFile::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_241_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEntryListFromFile::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__G__Tree_241_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   TEntryListFromFile* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new TEntryListFromFile(*(TEntryListFromFile*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__TreeLN_TEntryListFromFile));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TEntryListFromFile G__TTEntryListFromFile;
static int G__G__Tree_241_0_41(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[] (TEntryListFromFile*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TEntryListFromFile*) (soff+(sizeof(TEntryListFromFile)*i)))->~G__TTEntryListFromFile();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TEntryListFromFile*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TEntryListFromFile*) (soff))->~G__TTEntryListFromFile();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TLeafB */
static int G__G__Tree_245_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TLeafB* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TLeafB[n];
     } else {
       p = new((void*) gvp) TLeafB[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TLeafB;
     } else {
       p = new((void*) gvp) TLeafB;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__TreeLN_TLeafB));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_245_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TLeafB* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 3
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TLeafB(
(TBranch*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]));
   } else {
     p = new((void*) gvp) TLeafB(
(TBranch*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__TreeLN_TLeafB));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_245_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TLeafB*) G__getstructoffset())->SetMaximum((Char_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_245_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TLeafB*) G__getstructoffset())->SetMinimum((Char_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_245_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TLeafB::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_245_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TLeafB::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_245_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TLeafB::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_245_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TLeafB::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_245_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TLeafB*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_245_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TLeafB::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_245_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TLeafB::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_245_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TLeafB::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_245_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TLeafB::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__G__Tree_245_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   TLeafB* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new TLeafB(*(TLeafB*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__TreeLN_TLeafB));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TLeafB G__TTLeafB;
static int G__G__Tree_245_0_31(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[] (TLeafB*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TLeafB*) (soff+(sizeof(TLeafB)*i)))->~G__TTLeafB();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TLeafB*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TLeafB*) (soff))->~G__TTLeafB();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TLeafC */
static int G__G__Tree_246_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TLeafC* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TLeafC[n];
     } else {
       p = new((void*) gvp) TLeafC[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TLeafC;
     } else {
       p = new((void*) gvp) TLeafC;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__TreeLN_TLeafC));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_246_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TLeafC* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 3
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TLeafC(
(TBranch*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]));
   } else {
     p = new((void*) gvp) TLeafC(
(TBranch*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__TreeLN_TLeafC));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_246_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) ((const TLeafC*) G__getstructoffset())->GetValueString());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_246_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TLeafC::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_246_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TLeafC::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_246_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TLeafC::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_246_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TLeafC::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_246_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TLeafC*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_246_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TLeafC::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_246_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TLeafC::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_246_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TLeafC::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_246_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TLeafC::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__G__Tree_246_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   TLeafC* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new TLeafC(*(TLeafC*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__TreeLN_TLeafC));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TLeafC G__TTLeafC;
static int G__G__Tree_246_0_30(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[] (TLeafC*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TLeafC*) (soff+(sizeof(TLeafC)*i)))->~G__TTLeafC();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TLeafC*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TLeafC*) (soff))->~G__TTLeafC();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TLeafD */
static int G__G__Tree_247_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TLeafD* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TLeafD[n];
     } else {
       p = new((void*) gvp) TLeafD[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TLeafD;
     } else {
       p = new((void*) gvp) TLeafD;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__TreeLN_TLeafD));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_247_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TLeafD* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 3
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TLeafD(
(TBranch*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]));
   } else {
     p = new((void*) gvp) TLeafD(
(TBranch*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__TreeLN_TLeafD));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_247_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TLeafD::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_247_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TLeafD::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_247_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TLeafD::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_247_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TLeafD::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_247_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TLeafD*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_247_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TLeafD::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_247_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TLeafD::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_247_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TLeafD::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_247_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TLeafD::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__G__Tree_247_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   TLeafD* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new TLeafD(*(TLeafD*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__TreeLN_TLeafD));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TLeafD G__TTLeafD;
static int G__G__Tree_247_0_27(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[] (TLeafD*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TLeafD*) (soff+(sizeof(TLeafD)*i)))->~G__TTLeafD();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TLeafD*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TLeafD*) (soff))->~G__TTLeafD();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TLeafElement */
static int G__G__Tree_248_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TLeafElement* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TLeafElement[n];
     } else {
       p = new((void*) gvp) TLeafElement[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TLeafElement;
     } else {
       p = new((void*) gvp) TLeafElement;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__TreeLN_TLeafElement));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_248_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TLeafElement* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 4
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TLeafElement(
(TBranch*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3]));
   } else {
     p = new((void*) gvp) TLeafElement(
(TBranch*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__TreeLN_TLeafElement));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_248_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TLeafElement*) G__getstructoffset())->GetMethodCall((const char*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_248_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      G__letdouble(result7, 100, (double) ((const TLeafElement*) G__getstructoffset())->GetValueSubArray((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])));
      break;
   case 1:
      G__letdouble(result7, 100, (double) ((const TLeafElement*) G__getstructoffset())->GetValueSubArray((Int_t) G__int(libp->para[0])));
      break;
   case 0:
      G__letdouble(result7, 100, (double) ((const TLeafElement*) G__getstructoffset())->GetValueSubArray());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_248_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TLeafElement::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_248_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TLeafElement::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_248_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TLeafElement::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_248_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TLeafElement::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_248_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TLeafElement*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_248_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TLeafElement::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_248_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TLeafElement::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_248_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TLeafElement::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_248_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TLeafElement::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__G__Tree_248_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   TLeafElement* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new TLeafElement(*(TLeafElement*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__TreeLN_TLeafElement));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TLeafElement G__TTLeafElement;
static int G__G__Tree_248_0_27(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[] (TLeafElement*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TLeafElement*) (soff+(sizeof(TLeafElement)*i)))->~G__TTLeafElement();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TLeafElement*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TLeafElement*) (soff))->~G__TTLeafElement();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TLeafF */
static int G__G__Tree_249_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TLeafF* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TLeafF[n];
     } else {
       p = new((void*) gvp) TLeafF[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TLeafF;
     } else {
       p = new((void*) gvp) TLeafF;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__TreeLN_TLeafF));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_249_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TLeafF* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 3
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TLeafF(
(TBranch*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]));
   } else {
     p = new((void*) gvp) TLeafF(
(TBranch*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__TreeLN_TLeafF));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_249_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TLeafF::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_249_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TLeafF::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_249_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TLeafF::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_249_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TLeafF::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_249_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TLeafF*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_249_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TLeafF::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_249_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TLeafF::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_249_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TLeafF::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_249_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TLeafF::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__G__Tree_249_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   TLeafF* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new TLeafF(*(TLeafF*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__TreeLN_TLeafF));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TLeafF G__TTLeafF;
static int G__G__Tree_249_0_27(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[] (TLeafF*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TLeafF*) (soff+(sizeof(TLeafF)*i)))->~G__TTLeafF();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TLeafF*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TLeafF*) (soff))->~G__TTLeafF();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TLeafI */
static int G__G__Tree_250_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TLeafI* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TLeafI[n];
     } else {
       p = new((void*) gvp) TLeafI[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TLeafI;
     } else {
       p = new((void*) gvp) TLeafI;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__TreeLN_TLeafI));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_250_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TLeafI* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 3
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TLeafI(
(TBranch*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]));
   } else {
     p = new((void*) gvp) TLeafI(
(TBranch*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__TreeLN_TLeafI));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_250_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TLeafI*) G__getstructoffset())->SetMaximum((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_250_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TLeafI*) G__getstructoffset())->SetMinimum((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_250_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TLeafI::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_250_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TLeafI::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_250_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TLeafI::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_250_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TLeafI::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_250_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TLeafI*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_250_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TLeafI::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_250_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TLeafI::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_250_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TLeafI::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_250_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TLeafI::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__G__Tree_250_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   TLeafI* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new TLeafI(*(TLeafI*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__TreeLN_TLeafI));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TLeafI G__TTLeafI;
static int G__G__Tree_250_0_31(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[] (TLeafI*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TLeafI*) (soff+(sizeof(TLeafI)*i)))->~G__TTLeafI();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TLeafI*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TLeafI*) (soff))->~G__TTLeafI();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TLeafL */
static int G__G__Tree_251_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TLeafL* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TLeafL[n];
     } else {
       p = new((void*) gvp) TLeafL[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TLeafL;
     } else {
       p = new((void*) gvp) TLeafL;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__TreeLN_TLeafL));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_251_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TLeafL* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 3
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TLeafL(
(TBranch*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]));
   } else {
     p = new((void*) gvp) TLeafL(
(TBranch*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__TreeLN_TLeafL));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_251_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TLeafL*) G__getstructoffset())->SetMaximum((Long64_t) G__Longlong(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_251_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TLeafL*) G__getstructoffset())->SetMinimum((Long64_t) G__Longlong(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_251_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TLeafL::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_251_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TLeafL::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_251_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TLeafL::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_251_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TLeafL::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_251_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TLeafL*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_251_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TLeafL::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_251_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TLeafL::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_251_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TLeafL::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_251_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TLeafL::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__G__Tree_251_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   TLeafL* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new TLeafL(*(TLeafL*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__TreeLN_TLeafL));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TLeafL G__TTLeafL;
static int G__G__Tree_251_0_31(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[] (TLeafL*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TLeafL*) (soff+(sizeof(TLeafL)*i)))->~G__TTLeafL();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TLeafL*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TLeafL*) (soff))->~G__TTLeafL();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TLeafObject */
static int G__G__Tree_252_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TLeafObject* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TLeafObject[n];
     } else {
       p = new((void*) gvp) TLeafObject[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TLeafObject;
     } else {
       p = new((void*) gvp) TLeafObject;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__TreeLN_TLeafObject));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_252_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TLeafObject* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 3
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TLeafObject(
(TBranch*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]));
   } else {
     p = new((void*) gvp) TLeafObject(
(TBranch*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__TreeLN_TLeafObject));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_252_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TLeafObject*) G__getstructoffset())->GetClass());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_252_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TLeafObject*) G__getstructoffset())->GetMethodCall((const char*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_252_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TLeafObject*) G__getstructoffset())->GetObject());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_252_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TLeafObject*) G__getstructoffset())->IsVirtual());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_252_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TLeafObject*) G__getstructoffset())->SetVirtual((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TLeafObject*) G__getstructoffset())->SetVirtual();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_252_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TLeafObject::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_252_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TLeafObject::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_252_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TLeafObject::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_252_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TLeafObject::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_252_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TLeafObject*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_252_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TLeafObject::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_252_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TLeafObject::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_252_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TLeafObject::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_252_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TLeafObject::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__G__Tree_252_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   TLeafObject* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new TLeafObject(*(TLeafObject*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__TreeLN_TLeafObject));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TLeafObject G__TTLeafObject;
static int G__G__Tree_252_0_29(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[] (TLeafObject*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TLeafObject*) (soff+(sizeof(TLeafObject)*i)))->~G__TTLeafObject();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TLeafObject*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TLeafObject*) (soff))->~G__TTLeafObject();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TLeafO */
static int G__G__Tree_254_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TLeafO* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TLeafO[n];
     } else {
       p = new((void*) gvp) TLeafO[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TLeafO;
     } else {
       p = new((void*) gvp) TLeafO;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__TreeLN_TLeafO));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_254_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TLeafO* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 3
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TLeafO(
(TBranch*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]));
   } else {
     p = new((void*) gvp) TLeafO(
(TBranch*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__TreeLN_TLeafO));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_254_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TLeafO::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_254_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TLeafO::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_254_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TLeafO::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_254_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TLeafO::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_254_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TLeafO*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_254_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TLeafO::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_254_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TLeafO::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_254_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TLeafO::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_254_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TLeafO::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__G__Tree_254_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   TLeafO* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new TLeafO(*(TLeafO*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__TreeLN_TLeafO));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TLeafO G__TTLeafO;
static int G__G__Tree_254_0_27(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[] (TLeafO*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TLeafO*) (soff+(sizeof(TLeafO)*i)))->~G__TTLeafO();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TLeafO*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TLeafO*) (soff))->~G__TTLeafO();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TLeafS */
static int G__G__Tree_255_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TLeafS* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TLeafS[n];
     } else {
       p = new((void*) gvp) TLeafS[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TLeafS;
     } else {
       p = new((void*) gvp) TLeafS;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__TreeLN_TLeafS));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_255_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TLeafS* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 3
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TLeafS(
(TBranch*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]));
   } else {
     p = new((void*) gvp) TLeafS(
(TBranch*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__TreeLN_TLeafS));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_255_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TLeafS::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_255_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TLeafS::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_255_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TLeafS::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_255_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TLeafS::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_255_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TLeafS*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_255_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TLeafS::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_255_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TLeafS::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_255_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TLeafS::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_255_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TLeafS::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__G__Tree_255_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   TLeafS* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new TLeafS(*(TLeafS*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__TreeLN_TLeafS));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TLeafS G__TTLeafS;
static int G__G__Tree_255_0_27(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[] (TLeafS*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TLeafS*) (soff+(sizeof(TLeafS)*i)))->~G__TTLeafS();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TLeafS*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TLeafS*) (soff))->~G__TTLeafS();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TNtupleD */
static int G__G__Tree_256_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TNtupleD* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TNtupleD[n];
     } else {
       p = new((void*) gvp) TNtupleD[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TNtupleD;
     } else {
       p = new((void*) gvp) TNtupleD;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__TreeLN_TNtupleD));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_256_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TNtupleD* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 4:
     //m: 4
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TNtupleD(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]), (Int_t) G__int(libp->para[3]));
     } else {
       p = new((void*) gvp) TNtupleD(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]), (Int_t) G__int(libp->para[3]));
     }
     break;
   case 3:
     //m: 3
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TNtupleD(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]));
     } else {
       p = new((void*) gvp) TNtupleD(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]));
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__TreeLN_TNtupleD));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_256_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TNtupleD*) G__getstructoffset())->Fill((Double_t*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_256_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 15:
      G__letint(result7, 105, (long) ((TNtupleD*) G__getstructoffset())->Fill(
(Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5])
, (Double_t) G__double(libp->para[6]), (Double_t) G__double(libp->para[7])
, (Double_t) G__double(libp->para[8]), (Double_t) G__double(libp->para[9])
, (Double_t) G__double(libp->para[10]), (Double_t) G__double(libp->para[11])
, (Double_t) G__double(libp->para[12]), (Double_t) G__double(libp->para[13])
, (Double_t) G__double(libp->para[14])));
      break;
   case 14:
      G__letint(result7, 105, (long) ((TNtupleD*) G__getstructoffset())->Fill(
(Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5])
, (Double_t) G__double(libp->para[6]), (Double_t) G__double(libp->para[7])
, (Double_t) G__double(libp->para[8]), (Double_t) G__double(libp->para[9])
, (Double_t) G__double(libp->para[10]), (Double_t) G__double(libp->para[11])
, (Double_t) G__double(libp->para[12]), (Double_t) G__double(libp->para[13])));
      break;
   case 13:
      G__letint(result7, 105, (long) ((TNtupleD*) G__getstructoffset())->Fill(
(Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5])
, (Double_t) G__double(libp->para[6]), (Double_t) G__double(libp->para[7])
, (Double_t) G__double(libp->para[8]), (Double_t) G__double(libp->para[9])
, (Double_t) G__double(libp->para[10]), (Double_t) G__double(libp->para[11])
, (Double_t) G__double(libp->para[12])));
      break;
   case 12:
      G__letint(result7, 105, (long) ((TNtupleD*) G__getstructoffset())->Fill(
(Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5])
, (Double_t) G__double(libp->para[6]), (Double_t) G__double(libp->para[7])
, (Double_t) G__double(libp->para[8]), (Double_t) G__double(libp->para[9])
, (Double_t) G__double(libp->para[10]), (Double_t) G__double(libp->para[11])));
      break;
   case 11:
      G__letint(result7, 105, (long) ((TNtupleD*) G__getstructoffset())->Fill(
(Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5])
, (Double_t) G__double(libp->para[6]), (Double_t) G__double(libp->para[7])
, (Double_t) G__double(libp->para[8]), (Double_t) G__double(libp->para[9])
, (Double_t) G__double(libp->para[10])));
      break;
   case 10:
      G__letint(result7, 105, (long) ((TNtupleD*) G__getstructoffset())->Fill(
(Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5])
, (Double_t) G__double(libp->para[6]), (Double_t) G__double(libp->para[7])
, (Double_t) G__double(libp->para[8]), (Double_t) G__double(libp->para[9])));
      break;
   case 9:
      G__letint(result7, 105, (long) ((TNtupleD*) G__getstructoffset())->Fill(
(Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5])
, (Double_t) G__double(libp->para[6]), (Double_t) G__double(libp->para[7])
, (Double_t) G__double(libp->para[8])));
      break;
   case 8:
      G__letint(result7, 105, (long) ((TNtupleD*) G__getstructoffset())->Fill(
(Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5])
, (Double_t) G__double(libp->para[6]), (Double_t) G__double(libp->para[7])));
      break;
   case 7:
      G__letint(result7, 105, (long) ((TNtupleD*) G__getstructoffset())->Fill(
(Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5])
, (Double_t) G__double(libp->para[6])));
      break;
   case 6:
      G__letint(result7, 105, (long) ((TNtupleD*) G__getstructoffset())->Fill((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5])));
      break;
   case 5:
      G__letint(result7, 105, (long) ((TNtupleD*) G__getstructoffset())->Fill((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4])));
      break;
   case 4:
      G__letint(result7, 105, (long) ((TNtupleD*) G__getstructoffset())->Fill((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])));
      break;
   case 3:
      G__letint(result7, 105, (long) ((TNtupleD*) G__getstructoffset())->Fill((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2])));
      break;
   case 2:
      G__letint(result7, 105, (long) ((TNtupleD*) G__getstructoffset())->Fill((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_256_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TNtupleD*) G__getstructoffset())->GetNvar());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_256_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 68, (long) ((const TNtupleD*) G__getstructoffset())->GetArgs());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_256_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TNtupleD::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_256_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TNtupleD::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_256_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TNtupleD::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_256_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TNtupleD::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_256_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TNtupleD*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_256_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TNtupleD::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_256_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TNtupleD::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_256_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TNtupleD::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_256_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TNtupleD::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TNtupleD G__TTNtupleD;
static int G__G__Tree_256_0_26(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[] (TNtupleD*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TNtupleD*) (soff+(sizeof(TNtupleD)*i)))->~G__TTNtupleD();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TNtupleD*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TNtupleD*) (soff))->~G__TTNtupleD();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TNtuple */
static int G__G__Tree_257_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TNtuple* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TNtuple[n];
     } else {
       p = new((void*) gvp) TNtuple[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TNtuple;
     } else {
       p = new((void*) gvp) TNtuple;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__TreeLN_TNtuple));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_257_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TNtuple* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 4:
     //m: 4
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TNtuple(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]), (Int_t) G__int(libp->para[3]));
     } else {
       p = new((void*) gvp) TNtuple(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]), (Int_t) G__int(libp->para[3]));
     }
     break;
   case 3:
     //m: 3
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TNtuple(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]));
     } else {
       p = new((void*) gvp) TNtuple(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]));
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__TreeLN_TNtuple));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_257_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TNtuple*) G__getstructoffset())->Fill((Float_t*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_257_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TNtuple*) G__getstructoffset())->Fill((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_257_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TNtuple*) G__getstructoffset())->Fill((Double_t) G__double(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_257_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 15:
      G__letint(result7, 105, (long) ((TNtuple*) G__getstructoffset())->Fill(
(Float_t) G__double(libp->para[0]), (Float_t) G__double(libp->para[1])
, (Float_t) G__double(libp->para[2]), (Float_t) G__double(libp->para[3])
, (Float_t) G__double(libp->para[4]), (Float_t) G__double(libp->para[5])
, (Float_t) G__double(libp->para[6]), (Float_t) G__double(libp->para[7])
, (Float_t) G__double(libp->para[8]), (Float_t) G__double(libp->para[9])
, (Float_t) G__double(libp->para[10]), (Float_t) G__double(libp->para[11])
, (Float_t) G__double(libp->para[12]), (Float_t) G__double(libp->para[13])
, (Float_t) G__double(libp->para[14])));
      break;
   case 14:
      G__letint(result7, 105, (long) ((TNtuple*) G__getstructoffset())->Fill(
(Float_t) G__double(libp->para[0]), (Float_t) G__double(libp->para[1])
, (Float_t) G__double(libp->para[2]), (Float_t) G__double(libp->para[3])
, (Float_t) G__double(libp->para[4]), (Float_t) G__double(libp->para[5])
, (Float_t) G__double(libp->para[6]), (Float_t) G__double(libp->para[7])
, (Float_t) G__double(libp->para[8]), (Float_t) G__double(libp->para[9])
, (Float_t) G__double(libp->para[10]), (Float_t) G__double(libp->para[11])
, (Float_t) G__double(libp->para[12]), (Float_t) G__double(libp->para[13])));
      break;
   case 13:
      G__letint(result7, 105, (long) ((TNtuple*) G__getstructoffset())->Fill(
(Float_t) G__double(libp->para[0]), (Float_t) G__double(libp->para[1])
, (Float_t) G__double(libp->para[2]), (Float_t) G__double(libp->para[3])
, (Float_t) G__double(libp->para[4]), (Float_t) G__double(libp->para[5])
, (Float_t) G__double(libp->para[6]), (Float_t) G__double(libp->para[7])
, (Float_t) G__double(libp->para[8]), (Float_t) G__double(libp->para[9])
, (Float_t) G__double(libp->para[10]), (Float_t) G__double(libp->para[11])
, (Float_t) G__double(libp->para[12])));
      break;
   case 12:
      G__letint(result7, 105, (long) ((TNtuple*) G__getstructoffset())->Fill(
(Float_t) G__double(libp->para[0]), (Float_t) G__double(libp->para[1])
, (Float_t) G__double(libp->para[2]), (Float_t) G__double(libp->para[3])
, (Float_t) G__double(libp->para[4]), (Float_t) G__double(libp->para[5])
, (Float_t) G__double(libp->para[6]), (Float_t) G__double(libp->para[7])
, (Float_t) G__double(libp->para[8]), (Float_t) G__double(libp->para[9])
, (Float_t) G__double(libp->para[10]), (Float_t) G__double(libp->para[11])));
      break;
   case 11:
      G__letint(result7, 105, (long) ((TNtuple*) G__getstructoffset())->Fill(
(Float_t) G__double(libp->para[0]), (Float_t) G__double(libp->para[1])
, (Float_t) G__double(libp->para[2]), (Float_t) G__double(libp->para[3])
, (Float_t) G__double(libp->para[4]), (Float_t) G__double(libp->para[5])
, (Float_t) G__double(libp->para[6]), (Float_t) G__double(libp->para[7])
, (Float_t) G__double(libp->para[8]), (Float_t) G__double(libp->para[9])
, (Float_t) G__double(libp->para[10])));
      break;
   case 10:
      G__letint(result7, 105, (long) ((TNtuple*) G__getstructoffset())->Fill(
(Float_t) G__double(libp->para[0]), (Float_t) G__double(libp->para[1])
, (Float_t) G__double(libp->para[2]), (Float_t) G__double(libp->para[3])
, (Float_t) G__double(libp->para[4]), (Float_t) G__double(libp->para[5])
, (Float_t) G__double(libp->para[6]), (Float_t) G__double(libp->para[7])
, (Float_t) G__double(libp->para[8]), (Float_t) G__double(libp->para[9])));
      break;
   case 9:
      G__letint(result7, 105, (long) ((TNtuple*) G__getstructoffset())->Fill(
(Float_t) G__double(libp->para[0]), (Float_t) G__double(libp->para[1])
, (Float_t) G__double(libp->para[2]), (Float_t) G__double(libp->para[3])
, (Float_t) G__double(libp->para[4]), (Float_t) G__double(libp->para[5])
, (Float_t) G__double(libp->para[6]), (Float_t) G__double(libp->para[7])
, (Float_t) G__double(libp->para[8])));
      break;
   case 8:
      G__letint(result7, 105, (long) ((TNtuple*) G__getstructoffset())->Fill(
(Float_t) G__double(libp->para[0]), (Float_t) G__double(libp->para[1])
, (Float_t) G__double(libp->para[2]), (Float_t) G__double(libp->para[3])
, (Float_t) G__double(libp->para[4]), (Float_t) G__double(libp->para[5])
, (Float_t) G__double(libp->para[6]), (Float_t) G__double(libp->para[7])));
      break;
   case 7:
      G__letint(result7, 105, (long) ((TNtuple*) G__getstructoffset())->Fill(
(Float_t) G__double(libp->para[0]), (Float_t) G__double(libp->para[1])
, (Float_t) G__double(libp->para[2]), (Float_t) G__double(libp->para[3])
, (Float_t) G__double(libp->para[4]), (Float_t) G__double(libp->para[5])
, (Float_t) G__double(libp->para[6])));
      break;
   case 6:
      G__letint(result7, 105, (long) ((TNtuple*) G__getstructoffset())->Fill((Float_t) G__double(libp->para[0]), (Float_t) G__double(libp->para[1])
, (Float_t) G__double(libp->para[2]), (Float_t) G__double(libp->para[3])
, (Float_t) G__double(libp->para[4]), (Float_t) G__double(libp->para[5])));
      break;
   case 5:
      G__letint(result7, 105, (long) ((TNtuple*) G__getstructoffset())->Fill((Float_t) G__double(libp->para[0]), (Float_t) G__double(libp->para[1])
, (Float_t) G__double(libp->para[2]), (Float_t) G__double(libp->para[3])
, (Float_t) G__double(libp->para[4])));
      break;
   case 4:
      G__letint(result7, 105, (long) ((TNtuple*) G__getstructoffset())->Fill((Float_t) G__double(libp->para[0]), (Float_t) G__double(libp->para[1])
, (Float_t) G__double(libp->para[2]), (Float_t) G__double(libp->para[3])));
      break;
   case 3:
      G__letint(result7, 105, (long) ((TNtuple*) G__getstructoffset())->Fill((Float_t) G__double(libp->para[0]), (Float_t) G__double(libp->para[1])
, (Float_t) G__double(libp->para[2])));
      break;
   case 2:
      G__letint(result7, 105, (long) ((TNtuple*) G__getstructoffset())->Fill((Float_t) G__double(libp->para[0]), (Float_t) G__double(libp->para[1])));
      break;
   case 1:
      G__letint(result7, 105, (long) ((TNtuple*) G__getstructoffset())->Fill((Float_t) G__double(libp->para[0])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_257_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TNtuple*) G__getstructoffset())->GetNvar());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_257_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 70, (long) ((const TNtuple*) G__getstructoffset())->GetArgs());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_257_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TNtuple::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_257_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TNtuple::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_257_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TNtuple::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_257_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TNtuple::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_257_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TNtuple*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_257_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TNtuple::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_257_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TNtuple::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_257_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TNtuple::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_257_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TNtuple::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TNtuple G__TTNtuple;
static int G__G__Tree_257_0_28(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[] (TNtuple*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TNtuple*) (soff+(sizeof(TNtuple)*i)))->~G__TTNtuple();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TNtuple*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TNtuple*) (soff))->~G__TTNtuple();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TQueryResult */
static int G__G__Tree_261_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TQueryResult* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TQueryResult[n];
     } else {
       p = new((void*) gvp) TQueryResult[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TQueryResult;
     } else {
       p = new((void*) gvp) TQueryResult;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__TreeLN_TQueryResult));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_261_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TQueryResult*) G__getstructoffset())->Browse((TBrowser*) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TQueryResult*) G__getstructoffset())->Browse();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_261_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TQueryResult*) G__getstructoffset())->GetSeqNum());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_261_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TQueryResult*) G__getstructoffset())->GetStatus());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_261_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TDatime* pobj;
         const TDatime xobj = ((const TQueryResult*) G__getstructoffset())->GetStartTime();
         pobj = new TDatime(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_261_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TDatime* pobj;
         const TDatime xobj = ((const TQueryResult*) G__getstructoffset())->GetEndTime();
         pobj = new TDatime(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_261_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) ((const TQueryResult*) G__getstructoffset())->GetOptions());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_261_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TQueryResult*) G__getstructoffset())->GetInputList());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_261_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TQueryResult*) G__getstructoffset())->GetInputObject((const char*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_261_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letLonglong(result7, 110, (G__int64) ((const TQueryResult*) G__getstructoffset())->GetEntries());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_261_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letLonglong(result7, 110, (G__int64) ((const TQueryResult*) G__getstructoffset())->GetFirst());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_261_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letLonglong(result7, 110, (G__int64) ((const TQueryResult*) G__getstructoffset())->GetBytes());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_261_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const TQueryResult*) G__getstructoffset())->GetUsedCPU());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_261_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TQueryResult*) G__getstructoffset())->GetLogFile());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_261_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TQueryResult*) G__getstructoffset())->GetSelecHdr());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_261_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TQueryResult*) G__getstructoffset())->GetSelecImp());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_261_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) ((const TQueryResult*) G__getstructoffset())->GetLibList());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_261_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) ((const TQueryResult*) G__getstructoffset())->GetParList());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_261_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TQueryResult*) G__getstructoffset())->GetOutputList());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_261_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) ((const TQueryResult*) G__getstructoffset())->GetResultFile());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_261_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const TQueryResult*) G__getstructoffset())->GetInitTime());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_261_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const TQueryResult*) G__getstructoffset())->GetProcTime());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_261_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TQueryResult*) G__getstructoffset())->GetNumWrks());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_261_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TQueryResult*) G__getstructoffset())->IsArchived());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_261_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TQueryResult*) G__getstructoffset())->IsDone());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_261_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TQueryResult*) G__getstructoffset())->IsDraw());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_261_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TQueryResult*) G__getstructoffset())->IsFinalized());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_261_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((TQueryResult*) G__getstructoffset())->Matches((const char*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_261_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TQueryResult::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_261_0_42(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TQueryResult::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_261_0_43(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TQueryResult::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_261_0_44(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TQueryResult::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_261_0_48(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TQueryResult*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_261_0_49(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TQueryResult::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_261_0_50(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TQueryResult::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_261_0_51(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TQueryResult::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_261_0_52(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TQueryResult::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__G__Tree_261_0_53(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   TQueryResult* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new TQueryResult(*(TQueryResult*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__TreeLN_TQueryResult));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TQueryResult G__TTQueryResult;
static int G__G__Tree_261_0_54(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[] (TQueryResult*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TQueryResult*) (soff+(sizeof(TQueryResult)*i)))->~G__TTQueryResult();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TQueryResult*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TQueryResult*) (soff))->~G__TTQueryResult();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__G__Tree_261_0_55(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TQueryResult* dest = (TQueryResult*) G__getstructoffset();
   *dest = *(TQueryResult*) libp->para[0].ref;
   const TQueryResult& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TSelectorList */
static int G__G__Tree_269_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TSelectorList* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TSelectorList[n];
     } else {
       p = new((void*) gvp) TSelectorList[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TSelectorList;
     } else {
       p = new((void*) gvp) TSelectorList;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__TreeLN_TSelectorList));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_269_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TSelectorList::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_269_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TSelectorList::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_269_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TSelectorList::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_269_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TSelectorList::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_269_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TSelectorList*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_269_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TSelectorList::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_269_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TSelectorList::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_269_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TSelectorList::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_269_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TSelectorList::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TSelectorList G__TTSelectorList;
static int G__G__Tree_269_0_25(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[] (TSelectorList*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TSelectorList*) (soff+(sizeof(TSelectorList)*i)))->~G__TTSelectorList();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TSelectorList*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TSelectorList*) (soff))->~G__TTSelectorList();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TSelectorCint */
static int G__G__Tree_276_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TSelectorCint* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TSelectorCint[n];
     } else {
       p = new((void*) gvp) TSelectorCint[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TSelectorCint;
     } else {
       p = new((void*) gvp) TSelectorCint;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__TreeLN_TSelectorCint));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_276_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      ((TSelectorCint*) G__getstructoffset())->Build((TSelector*) G__int(libp->para[0]), (ClassInfo_t*) G__int(libp->para[1])
, (Bool_t) G__int(libp->para[2]));
      G__setnull(result7);
      break;
   case 2:
      ((TSelectorCint*) G__getstructoffset())->Build((TSelector*) G__int(libp->para[0]), (ClassInfo_t*) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_276_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TSelectorCint*) G__getstructoffset())->GetInterpretedClass());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_276_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TSelectorCint*) G__getstructoffset())->GetInterpretedSelector());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_276_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TSelectorCint::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_276_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TSelectorCint::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_276_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TSelectorCint::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_276_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TSelectorCint::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_276_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TSelectorCint*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_276_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TSelectorCint::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_276_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TSelectorCint::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_276_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TSelectorCint::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_276_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TSelectorCint::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TSelectorCint G__TTSelectorCint;
static int G__G__Tree_276_0_34(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[] (TSelectorCint*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TSelectorCint*) (soff+(sizeof(TSelectorCint)*i)))->~G__TTSelectorCint();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TSelectorCint*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TSelectorCint*) (soff))->~G__TTSelectorCint();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TSelectorScalar */
static int G__G__Tree_277_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TSelectorScalar* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 2:
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TSelectorScalar((const char*) G__int(libp->para[0]), (Long64_t) G__Longlong(libp->para[1]));
     } else {
       p = new((void*) gvp) TSelectorScalar((const char*) G__int(libp->para[0]), (Long64_t) G__Longlong(libp->para[1]));
     }
     break;
   case 1:
     //m: 1
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TSelectorScalar((const char*) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) TSelectorScalar((const char*) G__int(libp->para[0]));
     }
     break;
   case 0:
     int n = G__getaryconstruct();
     if (n) {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TSelectorScalar[n];
       } else {
         p = new((void*) gvp) TSelectorScalar[n];
       }
     } else {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TSelectorScalar;
       } else {
         p = new((void*) gvp) TSelectorScalar;
       }
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__TreeLN_TSelectorScalar));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_277_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TSelectorScalar*) G__getstructoffset())->Inc((Long_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TSelectorScalar*) G__getstructoffset())->Inc();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_277_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TSelectorScalar*) G__getstructoffset())->Merge((TCollection*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_277_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TSelectorScalar::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_277_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TSelectorScalar::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_277_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TSelectorScalar::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_277_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TSelectorScalar::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_277_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TSelectorScalar*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_277_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TSelectorScalar::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_277_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TSelectorScalar::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_277_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TSelectorScalar::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_277_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TSelectorScalar::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__G__Tree_277_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   TSelectorScalar* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new TSelectorScalar(*(TSelectorScalar*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__TreeLN_TSelectorScalar));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TSelectorScalar G__TTSelectorScalar;
static int G__G__Tree_277_0_17(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[] (TSelectorScalar*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TSelectorScalar*) (soff+(sizeof(TSelectorScalar)*i)))->~G__TTSelectorScalar();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TSelectorScalar*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TSelectorScalar*) (soff))->~G__TTSelectorScalar();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__G__Tree_277_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TSelectorScalar* dest = (TSelectorScalar*) G__getstructoffset();
   *dest = *(TSelectorScalar*) libp->para[0].ref;
   const TSelectorScalar& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TTreeCache */
static int G__G__Tree_280_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TTreeCache* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TTreeCache[n];
     } else {
       p = new((void*) gvp) TTreeCache[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TTreeCache;
     } else {
       p = new((void*) gvp) TTreeCache;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__TreeLN_TTreeCache));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_280_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TTreeCache* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 2:
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TTreeCache((TTree*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) TTreeCache((TTree*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
     }
     break;
   case 1:
     //m: 1
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TTreeCache((TTree*) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) TTreeCache((TTree*) G__int(libp->para[0]));
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__TreeLN_TTreeCache));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_280_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TTreeCache*) G__getstructoffset())->GetEfficiency());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_280_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TTreeCache*) G__getstructoffset())->GetEfficiencyRel());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_280_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TTreeCache::GetLearnEntries());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_280_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((TTreeCache*) G__getstructoffset())->FillBuffer());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_280_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TTreeCache*) G__getstructoffset())->GetOwner());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_280_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TTreeCache*) G__getstructoffset())->GetTree());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_280_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TTreeCache*) G__getstructoffset())->ResetCache();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_280_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TTreeCache*) G__getstructoffset())->SetEntryRange((Long64_t) G__Longlong(libp->para[0]), (Long64_t) G__Longlong(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_280_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      TTreeCache::SetLearnEntries((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      TTreeCache::SetLearnEntries();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_280_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TTreeCache*) G__getstructoffset())->StartLearningPhase();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_280_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TTreeCache*) G__getstructoffset())->StopLearningPhase();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_280_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((TTreeCache*) G__getstructoffset())->UpdateBranches((TTree*) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TTreeCache*) G__getstructoffset())->UpdateBranches((TTree*) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_280_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TTreeCache::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_280_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TTreeCache::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_280_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TTreeCache::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_280_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TTreeCache::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_280_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TTreeCache*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_280_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TTreeCache::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_280_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TTreeCache::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_280_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TTreeCache::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_280_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TTreeCache::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TTreeCache G__TTTreeCache;
static int G__G__Tree_280_0_34(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[] (TTreeCache*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TTreeCache*) (soff+(sizeof(TTreeCache)*i)))->~G__TTTreeCache();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TTreeCache*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TTreeCache*) (soff))->~G__TTTreeCache();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TTreeCacheUnzip */
static int G__G__Tree_284_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TTreeCacheUnzip* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TTreeCacheUnzip[n];
     } else {
       p = new((void*) gvp) TTreeCacheUnzip[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TTreeCacheUnzip;
     } else {
       p = new((void*) gvp) TTreeCacheUnzip;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__TreeLN_TTreeCacheUnzip));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_284_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TTreeCacheUnzip* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 2:
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TTreeCacheUnzip((TTree*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) TTreeCacheUnzip((TTree*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
     }
     break;
   case 1:
     //m: 1
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TTreeCacheUnzip((TTree*) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) TTreeCacheUnzip((TTree*) G__int(libp->para[0]));
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__TreeLN_TTreeCacheUnzip));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_284_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TTreeCacheUnzip::GetParallelUnzip());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_284_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) TTreeCacheUnzip::IsParallelUnzip());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_284_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      G__letint(result7, 105, (long) TTreeCacheUnzip::SetParallelUnzip((TTreeCacheUnzip::EParUnzipMode) G__int(libp->para[0])));
      break;
   case 0:
      G__letint(result7, 105, (long) TTreeCacheUnzip::SetParallelUnzip());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_284_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((TTreeCacheUnzip*) G__getstructoffset())->IsActiveThread());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_284_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((TTreeCacheUnzip*) G__getstructoffset())->IsQueueEmpty());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_284_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TTreeCacheUnzip*) G__getstructoffset())->WaitUnzipStartSignal();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_284_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TTreeCacheUnzip*) G__getstructoffset())->SendUnzipStartSignal((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_284_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TTreeCacheUnzip*) G__getstructoffset())->GetRecordHeader((char*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, *(Int_t*) G__Intref(&libp->para[2]), *(Int_t*) G__Intref(&libp->para[3])
, *(Int_t*) G__Intref(&libp->para[4])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_284_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TTreeCacheUnzip*) G__getstructoffset())->SetUnzipBufferSize((Long64_t) G__Longlong(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_284_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TTreeCacheUnzip::SetUnzipRelBufferSize((Float_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_284_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TTreeCacheUnzip*) G__getstructoffset())->UnzipBuffer((char**) G__int(libp->para[0]), (char*) G__int(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_284_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TTreeCacheUnzip*) G__getstructoffset())->UnzipCache(*(Int_t*) G__Intref(&libp->para[0]), *(Int_t*) G__Intref(&libp->para[1])
, libp->para[2].ref ? *(char**) libp->para[2].ref : *(char**) (void*) (&G__Mlong(libp->para[2]))));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_284_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TTreeCacheUnzip*) G__getstructoffset())->GetNUnzip());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_284_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TTreeCacheUnzip*) G__getstructoffset())->GetNFound());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_284_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TTreeCacheUnzip*) G__getstructoffset())->GetNMissed());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_284_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 89, (long) TTreeCacheUnzip::UnzipLoop((void*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_284_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TTreeCacheUnzip::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_284_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TTreeCacheUnzip::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_284_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TTreeCacheUnzip::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_284_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TTreeCacheUnzip::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_284_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TTreeCacheUnzip*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_284_0_42(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TTreeCacheUnzip::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_284_0_43(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TTreeCacheUnzip::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_284_0_44(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TTreeCacheUnzip::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_284_0_45(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TTreeCacheUnzip::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TTreeCacheUnzip G__TTTreeCacheUnzip;
static int G__G__Tree_284_0_46(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[] (TTreeCacheUnzip*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TTreeCacheUnzip*) (soff+(sizeof(TTreeCacheUnzip)*i)))->~G__TTTreeCacheUnzip();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TTreeCacheUnzip*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TTreeCacheUnzip*) (soff))->~G__TTTreeCacheUnzip();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TTreeResult */
static int G__G__Tree_294_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TTreeResult* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TTreeResult[n];
     } else {
       p = new((void*) gvp) TTreeResult[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TTreeResult;
     } else {
       p = new((void*) gvp) TTreeResult;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__TreeLN_TTreeResult));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_294_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TTreeResult* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TTreeResult((Int_t) G__int(libp->para[0]));
   } else {
     p = new((void*) gvp) TTreeResult((Int_t) G__int(libp->para[0]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__TreeLN_TTreeResult));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_294_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TTreeResult*) G__getstructoffset())->GetRows());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_294_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TTreeResult::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_294_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TTreeResult::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_294_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TTreeResult::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_294_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TTreeResult::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_294_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TTreeResult*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_294_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TTreeResult::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_294_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TTreeResult::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_294_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TTreeResult::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_294_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TTreeResult::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__G__Tree_294_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   TTreeResult* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new TTreeResult(*(TTreeResult*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__TreeLN_TTreeResult));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TTreeResult G__TTTreeResult;
static int G__G__Tree_294_0_24(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[] (TTreeResult*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TTreeResult*) (soff+(sizeof(TTreeResult)*i)))->~G__TTTreeResult();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TTreeResult*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TTreeResult*) (soff))->~G__TTTreeResult();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__G__Tree_294_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TTreeResult* dest = (TTreeResult*) G__getstructoffset();
   *dest = *(TTreeResult*) libp->para[0].ref;
   const TTreeResult& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TTreeRow */
static int G__G__Tree_295_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TTreeRow* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TTreeRow[n];
     } else {
       p = new((void*) gvp) TTreeRow[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TTreeRow;
     } else {
       p = new((void*) gvp) TTreeRow;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__TreeLN_TTreeRow));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_295_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TTreeRow* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TTreeRow((Int_t) G__int(libp->para[0]));
   } else {
     p = new((void*) gvp) TTreeRow((Int_t) G__int(libp->para[0]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__TreeLN_TTreeRow));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_295_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TTreeRow* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 3
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TTreeRow(
(Int_t) G__int(libp->para[0]), (const Int_t*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]));
   } else {
     p = new((void*) gvp) TTreeRow(
(Int_t) G__int(libp->para[0]), (const Int_t*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__TreeLN_TTreeRow));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_295_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TTreeRow*) G__getstructoffset())->SetRow((const Int_t*) G__int(libp->para[0]), (const char*) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_295_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TTreeRow::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_295_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TTreeRow::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_295_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TTreeRow::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_295_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TTreeRow::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_295_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TTreeRow*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_295_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TTreeRow::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_295_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TTreeRow::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_295_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TTreeRow::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_295_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TTreeRow::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__G__Tree_295_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   TTreeRow* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new TTreeRow(*(TTreeRow*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__TreeLN_TTreeRow));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TTreeRow G__TTTreeRow;
static int G__G__Tree_295_0_23(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[] (TTreeRow*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TTreeRow*) (soff+(sizeof(TTreeRow)*i)))->~G__TTTreeRow();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TTreeRow*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TTreeRow*) (soff))->~G__TTTreeRow();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__G__Tree_295_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TTreeRow* dest = (TTreeRow*) G__getstructoffset();
   *dest = *(TTreeRow*) libp->para[0].ref;
   const TTreeRow& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TTreeSQL */
static int G__G__Tree_297_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TTreeSQL* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 3
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TTreeSQL(
(TSQLServer*) G__int(libp->para[0]), *((TString*) G__int(libp->para[1]))
, *(TString*) libp->para[2].ref);
   } else {
     p = new((void*) gvp) TTreeSQL(
(TSQLServer*) G__int(libp->para[0]), *((TString*) G__int(libp->para[1]))
, *(TString*) libp->para[2].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__TreeLN_TTreeSQL));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_297_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TString* pobj;
         TString xobj = ((TTreeSQL*) G__getstructoffset())->GetTableName();
         pobj = new TString(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_297_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letLonglong(result7, 110, (G__int64) ((TTreeSQL*) G__getstructoffset())->PrepEntry((Long64_t) G__Longlong(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_297_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TTreeSQL::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_297_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TTreeSQL::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_297_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TTreeSQL::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_297_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TTreeSQL::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_297_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TTreeSQL*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_297_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TTreeSQL::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_297_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TTreeSQL::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_297_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TTreeSQL::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree_297_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TTreeSQL::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TTreeSQL G__TTTreeSQL;
static int G__G__Tree_297_0_42(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[] (TTreeSQL*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TTreeSQL*) (soff+(sizeof(TTreeSQL)*i)))->~G__TTTreeSQL();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TTreeSQL*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TTreeSQL*) (soff))->~G__TTTreeSQL();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* Setting up global function */
static int G__G__Tree__0_674(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TCut* pobj;
         TCut xobj = operator+(*(TCut*) libp->para[0].ref, (const char*) G__int(libp->para[1]));
         pobj = new TCut(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree__0_675(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TCut* pobj;
         TCut xobj = operator+((const char*) G__int(libp->para[0]), *(TCut*) libp->para[1].ref);
         pobj = new TCut(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree__0_676(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TCut* pobj;
         TCut xobj = operator+(*(TCut*) libp->para[0].ref, *(TCut*) libp->para[1].ref);
         pobj = new TCut(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree__0_677(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TCut* pobj;
         TCut xobj = operator*(*(TCut*) libp->para[0].ref, (const char*) G__int(libp->para[1]));
         pobj = new TCut(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree__0_678(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TCut* pobj;
         TCut xobj = operator*((const char*) G__int(libp->para[0]), *(TCut*) libp->para[1].ref);
         pobj = new TCut(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree__0_679(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TCut* pobj;
         TCut xobj = operator*(*(TCut*) libp->para[0].ref, *(TCut*) libp->para[1].ref);
         pobj = new TCut(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree__0_680(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TCut* pobj;
         TCut xobj = operator&&(*(TCut*) libp->para[0].ref, (const char*) G__int(libp->para[1]));
         pobj = new TCut(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree__0_681(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TCut* pobj;
         TCut xobj = operator&&((const char*) G__int(libp->para[0]), *(TCut*) libp->para[1].ref);
         pobj = new TCut(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree__0_682(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TCut* pobj;
         TCut xobj = operator&&(*(TCut*) libp->para[0].ref, *(TCut*) libp->para[1].ref);
         pobj = new TCut(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree__0_683(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TCut* pobj;
         TCut xobj = operator||(*(TCut*) libp->para[0].ref, (const char*) G__int(libp->para[1]));
         pobj = new TCut(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree__0_684(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TCut* pobj;
         TCut xobj = operator||((const char*) G__int(libp->para[0]), *(TCut*) libp->para[1].ref);
         pobj = new TCut(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree__0_685(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TCut* pobj;
         TCut xobj = operator||(*(TCut*) libp->para[0].ref, *(TCut*) libp->para[1].ref);
         pobj = new TCut(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree__0_686(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TCut* pobj;
         TCut xobj = operator!(*(TCut*) libp->para[0].ref);
         pobj = new TCut(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree__0_688(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TEventList* pobj;
         TEventList xobj = operator+(*(TEventList*) libp->para[0].ref, *(TEventList*) libp->para[1].ref);
         pobj = new TEventList(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree__0_689(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TEventList* pobj;
         TEventList xobj = operator-(*(TEventList*) libp->para[0].ref, *(TEventList*) libp->para[1].ref);
         pobj = new TEventList(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Tree__0_690(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TEventList* pobj;
         TEventList xobj = operator*(*(TEventList*) libp->para[0].ref, *(TEventList*) libp->para[1].ref);
         pobj = new TEventList(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}


/*********************************************************
* Member function Stub
*********************************************************/

/* TTree */

/* TBranch */

/* TBasket */

/* TBufferSQL */

/* TBasketSQL */

/* TBranchElement */

/* TVirtualBranchBrowsable */

/* TMethodBrowsable */

/* TNonSplitBrowsable */

/* TCollectionPropertyBrowsable */

/* TCollectionMethodBrowsable */

/* TLeaf */

/* TTreeCloner */

/* TBranchClones */

/* TSelector */

/* TVirtualIndex */

/* TVirtualTreePlayer */

/* TEventList */

/* TEntryList */

/* TFriendElement */

/* TCut */

/* TBranchRef */

/* TTreeFriendLeafIter */

/* TBranchObject */

/* TIndArray */

/* TBranchSTL */

/* TChainElement */

/* TChain */

/* TEntryListBlock */

/* TEntryListFromFile */

/* TLeafB */

/* TLeafC */

/* TLeafD */

/* TLeafElement */

/* TLeafF */

/* TLeafI */

/* TLeafL */

/* TLeafObject */

/* TLeafO */

/* TLeafS */

/* TNtupleD */

/* TNtuple */

/* TQueryResult */

/* TSelectorList */

/* TSelectorCint */

/* TSelectorScalar */

/* TTreeCache */

/* TTreeCacheUnzip */

/* TTreeResult */

/* TTreeRow */

/* TTreeSQL */

/*********************************************************
* Global function Stub
*********************************************************/

/*********************************************************
* Get size of pointer to member function
*********************************************************/
class G__Sizep2memfuncG__Tree {
 public:
  G__Sizep2memfuncG__Tree(): p(&G__Sizep2memfuncG__Tree::sizep2memfunc) {}
    size_t sizep2memfunc() { return(sizeof(p)); }
  private:
    size_t (G__Sizep2memfuncG__Tree::*p)();
};

size_t G__get_sizep2memfuncG__Tree()
{
  G__Sizep2memfuncG__Tree 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_inheritanceG__Tree() {

   /* Setting up class inheritance */
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__TreeLN_TTree))) {
     TTree *G__Lderived;
     G__Lderived=(TTree*)0x1000;
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TreeLN_TTree),G__get_linked_tagnum(&G__G__TreeLN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TreeLN_TTree),G__get_linked_tagnum(&G__G__TreeLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TAttLine *G__Lpbase=(TAttLine*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TreeLN_TTree),G__get_linked_tagnum(&G__G__TreeLN_TAttLine),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TAttFill *G__Lpbase=(TAttFill*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TreeLN_TTree),G__get_linked_tagnum(&G__G__TreeLN_TAttFill),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TAttMarker *G__Lpbase=(TAttMarker*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TreeLN_TTree),G__get_linked_tagnum(&G__G__TreeLN_TAttMarker),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__TreeLN_TBranch))) {
     TBranch *G__Lderived;
     G__Lderived=(TBranch*)0x1000;
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TreeLN_TBranch),G__get_linked_tagnum(&G__G__TreeLN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TreeLN_TBranch),G__get_linked_tagnum(&G__G__TreeLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TAttFill *G__Lpbase=(TAttFill*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TreeLN_TBranch),G__get_linked_tagnum(&G__G__TreeLN_TAttFill),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__TreeLN_TBasket))) {
     TBasket *G__Lderived;
     G__Lderived=(TBasket*)0x1000;
     {
       TKey *G__Lpbase=(TKey*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TreeLN_TBasket),G__get_linked_tagnum(&G__G__TreeLN_TKey),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TreeLN_TBasket),G__get_linked_tagnum(&G__G__TreeLN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TreeLN_TBasket),G__get_linked_tagnum(&G__G__TreeLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__TreeLN_TBufferSQL))) {
     TBufferSQL *G__Lderived;
     G__Lderived=(TBufferSQL*)0x1000;
     {
       TBufferFile *G__Lpbase=(TBufferFile*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TreeLN_TBufferSQL),G__get_linked_tagnum(&G__G__TreeLN_TBufferFile),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TBuffer *G__Lpbase=(TBuffer*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TreeLN_TBufferSQL),G__get_linked_tagnum(&G__G__TreeLN_TBuffer),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TreeLN_TBufferSQL),G__get_linked_tagnum(&G__G__TreeLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__TreeLN_TBasketSQL))) {
     TBasketSQL *G__Lderived;
     G__Lderived=(TBasketSQL*)0x1000;
     {
       TBasket *G__Lpbase=(TBasket*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TreeLN_TBasketSQL),G__get_linked_tagnum(&G__G__TreeLN_TBasket),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TKey *G__Lpbase=(TKey*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TreeLN_TBasketSQL),G__get_linked_tagnum(&G__G__TreeLN_TKey),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TreeLN_TBasketSQL),G__get_linked_tagnum(&G__G__TreeLN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TreeLN_TBasketSQL),G__get_linked_tagnum(&G__G__TreeLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__TreeLN_TBranchElement))) {
     TBranchElement *G__Lderived;
     G__Lderived=(TBranchElement*)0x1000;
     {
       TBranch *G__Lpbase=(TBranch*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TreeLN_TBranchElement),G__get_linked_tagnum(&G__G__TreeLN_TBranch),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TreeLN_TBranchElement),G__get_linked_tagnum(&G__G__TreeLN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TreeLN_TBranchElement),G__get_linked_tagnum(&G__G__TreeLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TAttFill *G__Lpbase=(TAttFill*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TreeLN_TBranchElement),G__get_linked_tagnum(&G__G__TreeLN_TAttFill),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__TreeLN_TVirtualBranchBrowsable))) {
     TVirtualBranchBrowsable *G__Lderived;
     G__Lderived=(TVirtualBranchBrowsable*)0x1000;
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TreeLN_TVirtualBranchBrowsable),G__get_linked_tagnum(&G__G__TreeLN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TreeLN_TVirtualBranchBrowsable),G__get_linked_tagnum(&G__G__TreeLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__TreeLN_TMethodBrowsable))) {
     TMethodBrowsable *G__Lderived;
     G__Lderived=(TMethodBrowsable*)0x1000;
     {
       TVirtualBranchBrowsable *G__Lpbase=(TVirtualBranchBrowsable*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TreeLN_TMethodBrowsable),G__get_linked_tagnum(&G__G__TreeLN_TVirtualBranchBrowsable),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TreeLN_TMethodBrowsable),G__get_linked_tagnum(&G__G__TreeLN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TreeLN_TMethodBrowsable),G__get_linked_tagnum(&G__G__TreeLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__TreeLN_TNonSplitBrowsable))) {
     TNonSplitBrowsable *G__Lderived;
     G__Lderived=(TNonSplitBrowsable*)0x1000;
     {
       TVirtualBranchBrowsable *G__Lpbase=(TVirtualBranchBrowsable*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TreeLN_TNonSplitBrowsable),G__get_linked_tagnum(&G__G__TreeLN_TVirtualBranchBrowsable),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TreeLN_TNonSplitBrowsable),G__get_linked_tagnum(&G__G__TreeLN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TreeLN_TNonSplitBrowsable),G__get_linked_tagnum(&G__G__TreeLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__TreeLN_TCollectionPropertyBrowsable))) {
     TCollectionPropertyBrowsable *G__Lderived;
     G__Lderived=(TCollectionPropertyBrowsable*)0x1000;
     {
       TVirtualBranchBrowsable *G__Lpbase=(TVirtualBranchBrowsable*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TreeLN_TCollectionPropertyBrowsable),G__get_linked_tagnum(&G__G__TreeLN_TVirtualBranchBrowsable),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TreeLN_TCollectionPropertyBrowsable),G__get_linked_tagnum(&G__G__TreeLN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TreeLN_TCollectionPropertyBrowsable),G__get_linked_tagnum(&G__G__TreeLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__TreeLN_TCollectionMethodBrowsable))) {
     TCollectionMethodBrowsable *G__Lderived;
     G__Lderived=(TCollectionMethodBrowsable*)0x1000;
     {
       TMethodBrowsable *G__Lpbase=(TMethodBrowsable*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TreeLN_TCollectionMethodBrowsable),G__get_linked_tagnum(&G__G__TreeLN_TMethodBrowsable),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TVirtualBranchBrowsable *G__Lpbase=(TVirtualBranchBrowsable*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TreeLN_TCollectionMethodBrowsable),G__get_linked_tagnum(&G__G__TreeLN_TVirtualBranchBrowsable),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TreeLN_TCollectionMethodBrowsable),G__get_linked_tagnum(&G__G__TreeLN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TreeLN_TCollectionMethodBrowsable),G__get_linked_tagnum(&G__G__TreeLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__TreeLN_TLeaf))) {
     TLeaf *G__Lderived;
     G__Lderived=(TLeaf*)0x1000;
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TreeLN_TLeaf),G__get_linked_tagnum(&G__G__TreeLN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TreeLN_TLeaf),G__get_linked_tagnum(&G__G__TreeLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__TreeLN_TBranchClones))) {
     TBranchClones *G__Lderived;
     G__Lderived=(TBranchClones*)0x1000;
     {
       TBranch *G__Lpbase=(TBranch*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TreeLN_TBranchClones),G__get_linked_tagnum(&G__G__TreeLN_TBranch),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TreeLN_TBranchClones),G__get_linked_tagnum(&G__G__TreeLN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TreeLN_TBranchClones),G__get_linked_tagnum(&G__G__TreeLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TAttFill *G__Lpbase=(TAttFill*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TreeLN_TBranchClones),G__get_linked_tagnum(&G__G__TreeLN_TAttFill),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__TreeLN_TSelector))) {
     TSelector *G__Lderived;
     G__Lderived=(TSelector*)0x1000;
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TreeLN_TSelector),G__get_linked_tagnum(&G__G__TreeLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__TreeLN_TVirtualIndex))) {
     TVirtualIndex *G__Lderived;
     G__Lderived=(TVirtualIndex*)0x1000;
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TreeLN_TVirtualIndex),G__get_linked_tagnum(&G__G__TreeLN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TreeLN_TVirtualIndex),G__get_linked_tagnum(&G__G__TreeLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__TreeLN_TVirtualTreePlayer))) {
     TVirtualTreePlayer *G__Lderived;
     G__Lderived=(TVirtualTreePlayer*)0x1000;
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TreeLN_TVirtualTreePlayer),G__get_linked_tagnum(&G__G__TreeLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__TreeLN_TEventList))) {
     TEventList *G__Lderived;
     G__Lderived=(TEventList*)0x1000;
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TreeLN_TEventList),G__get_linked_tagnum(&G__G__TreeLN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TreeLN_TEventList),G__get_linked_tagnum(&G__G__TreeLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__TreeLN_TEntryList))) {
     TEntryList *G__Lderived;
     G__Lderived=(TEntryList*)0x1000;
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TreeLN_TEntryList),G__get_linked_tagnum(&G__G__TreeLN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TreeLN_TEntryList),G__get_linked_tagnum(&G__G__TreeLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__TreeLN_TFriendElement))) {
     TFriendElement *G__Lderived;
     G__Lderived=(TFriendElement*)0x1000;
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TreeLN_TFriendElement),G__get_linked_tagnum(&G__G__TreeLN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TreeLN_TFriendElement),G__get_linked_tagnum(&G__G__TreeLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__TreeLN_TCut))) {
     TCut *G__Lderived;
     G__Lderived=(TCut*)0x1000;
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TreeLN_TCut),G__get_linked_tagnum(&G__G__TreeLN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TreeLN_TCut),G__get_linked_tagnum(&G__G__TreeLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__TreeLN_TBranchRef))) {
     TBranchRef *G__Lderived;
     G__Lderived=(TBranchRef*)0x1000;
     {
       TBranch *G__Lpbase=(TBranch*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TreeLN_TBranchRef),G__get_linked_tagnum(&G__G__TreeLN_TBranch),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TreeLN_TBranchRef),G__get_linked_tagnum(&G__G__TreeLN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TreeLN_TBranchRef),G__get_linked_tagnum(&G__G__TreeLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TAttFill *G__Lpbase=(TAttFill*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TreeLN_TBranchRef),G__get_linked_tagnum(&G__G__TreeLN_TAttFill),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__TreeLN_TTreeFriendLeafIter))) {
     TTreeFriendLeafIter *G__Lderived;
     G__Lderived=(TTreeFriendLeafIter*)0x1000;
     {
       TIterator *G__Lpbase=(TIterator*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TreeLN_TTreeFriendLeafIter),G__get_linked_tagnum(&G__G__TreeLN_TIterator),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__TreeLN_TBranchObject))) {
     TBranchObject *G__Lderived;
     G__Lderived=(TBranchObject*)0x1000;
     {
       TBranch *G__Lpbase=(TBranch*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TreeLN_TBranchObject),G__get_linked_tagnum(&G__G__TreeLN_TBranch),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TreeLN_TBranchObject),G__get_linked_tagnum(&G__G__TreeLN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TreeLN_TBranchObject),G__get_linked_tagnum(&G__G__TreeLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TAttFill *G__Lpbase=(TAttFill*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TreeLN_TBranchObject),G__get_linked_tagnum(&G__G__TreeLN_TAttFill),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__TreeLN_TBranchSTL))) {
     TBranchSTL *G__Lderived;
     G__Lderived=(TBranchSTL*)0x1000;
     {
       TBranch *G__Lpbase=(TBranch*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TreeLN_TBranchSTL),G__get_linked_tagnum(&G__G__TreeLN_TBranch),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TreeLN_TBranchSTL),G__get_linked_tagnum(&G__G__TreeLN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TreeLN_TBranchSTL),G__get_linked_tagnum(&G__G__TreeLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TAttFill *G__Lpbase=(TAttFill*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TreeLN_TBranchSTL),G__get_linked_tagnum(&G__G__TreeLN_TAttFill),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__TreeLN_TBufferFile))) {
     TBufferFile *G__Lderived;
     G__Lderived=(TBufferFile*)0x1000;
     {
       TBuffer *G__Lpbase=(TBuffer*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TreeLN_TBufferFile),G__get_linked_tagnum(&G__G__TreeLN_TBuffer),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TreeLN_TBufferFile),G__get_linked_tagnum(&G__G__TreeLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__TreeLN_TChainElement))) {
     TChainElement *G__Lderived;
     G__Lderived=(TChainElement*)0x1000;
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TreeLN_TChainElement),G__get_linked_tagnum(&G__G__TreeLN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TreeLN_TChainElement),G__get_linked_tagnum(&G__G__TreeLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__TreeLN_TChain))) {
     TChain *G__Lderived;
     G__Lderived=(TChain*)0x1000;
     {
       TTree *G__Lpbase=(TTree*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TreeLN_TChain),G__get_linked_tagnum(&G__G__TreeLN_TTree),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TreeLN_TChain),G__get_linked_tagnum(&G__G__TreeLN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TreeLN_TChain),G__get_linked_tagnum(&G__G__TreeLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TAttLine *G__Lpbase=(TAttLine*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TreeLN_TChain),G__get_linked_tagnum(&G__G__TreeLN_TAttLine),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TAttFill *G__Lpbase=(TAttFill*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TreeLN_TChain),G__get_linked_tagnum(&G__G__TreeLN_TAttFill),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TAttMarker *G__Lpbase=(TAttMarker*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TreeLN_TChain),G__get_linked_tagnum(&G__G__TreeLN_TAttMarker),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__TreeLN_TEntryListBlock))) {
     TEntryListBlock *G__Lderived;
     G__Lderived=(TEntryListBlock*)0x1000;
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TreeLN_TEntryListBlock),G__get_linked_tagnum(&G__G__TreeLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__TreeLN_TEntryListFromFile))) {
     TEntryListFromFile *G__Lderived;
     G__Lderived=(TEntryListFromFile*)0x1000;
     {
       TEntryList *G__Lpbase=(TEntryList*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TreeLN_TEntryListFromFile),G__get_linked_tagnum(&G__G__TreeLN_TEntryList),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TreeLN_TEntryListFromFile),G__get_linked_tagnum(&G__G__TreeLN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TreeLN_TEntryListFromFile),G__get_linked_tagnum(&G__G__TreeLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__TreeLN_TLeafB))) {
     TLeafB *G__Lderived;
     G__Lderived=(TLeafB*)0x1000;
     {
       TLeaf *G__Lpbase=(TLeaf*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TreeLN_TLeafB),G__get_linked_tagnum(&G__G__TreeLN_TLeaf),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TreeLN_TLeafB),G__get_linked_tagnum(&G__G__TreeLN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TreeLN_TLeafB),G__get_linked_tagnum(&G__G__TreeLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__TreeLN_TLeafC))) {
     TLeafC *G__Lderived;
     G__Lderived=(TLeafC*)0x1000;
     {
       TLeaf *G__Lpbase=(TLeaf*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TreeLN_TLeafC),G__get_linked_tagnum(&G__G__TreeLN_TLeaf),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TreeLN_TLeafC),G__get_linked_tagnum(&G__G__TreeLN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TreeLN_TLeafC),G__get_linked_tagnum(&G__G__TreeLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__TreeLN_TLeafD))) {
     TLeafD *G__Lderived;
     G__Lderived=(TLeafD*)0x1000;
     {
       TLeaf *G__Lpbase=(TLeaf*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TreeLN_TLeafD),G__get_linked_tagnum(&G__G__TreeLN_TLeaf),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TreeLN_TLeafD),G__get_linked_tagnum(&G__G__TreeLN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TreeLN_TLeafD),G__get_linked_tagnum(&G__G__TreeLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__TreeLN_TLeafElement))) {
     TLeafElement *G__Lderived;
     G__Lderived=(TLeafElement*)0x1000;
     {
       TLeaf *G__Lpbase=(TLeaf*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TreeLN_TLeafElement),G__get_linked_tagnum(&G__G__TreeLN_TLeaf),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TreeLN_TLeafElement),G__get_linked_tagnum(&G__G__TreeLN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TreeLN_TLeafElement),G__get_linked_tagnum(&G__G__TreeLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__TreeLN_TLeafF))) {
     TLeafF *G__Lderived;
     G__Lderived=(TLeafF*)0x1000;
     {
       TLeaf *G__Lpbase=(TLeaf*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TreeLN_TLeafF),G__get_linked_tagnum(&G__G__TreeLN_TLeaf),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TreeLN_TLeafF),G__get_linked_tagnum(&G__G__TreeLN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TreeLN_TLeafF),G__get_linked_tagnum(&G__G__TreeLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__TreeLN_TLeafI))) {
     TLeafI *G__Lderived;
     G__Lderived=(TLeafI*)0x1000;
     {
       TLeaf *G__Lpbase=(TLeaf*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TreeLN_TLeafI),G__get_linked_tagnum(&G__G__TreeLN_TLeaf),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TreeLN_TLeafI),G__get_linked_tagnum(&G__G__TreeLN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TreeLN_TLeafI),G__get_linked_tagnum(&G__G__TreeLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__TreeLN_TLeafL))) {
     TLeafL *G__Lderived;
     G__Lderived=(TLeafL*)0x1000;
     {
       TLeaf *G__Lpbase=(TLeaf*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TreeLN_TLeafL),G__get_linked_tagnum(&G__G__TreeLN_TLeaf),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TreeLN_TLeafL),G__get_linked_tagnum(&G__G__TreeLN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TreeLN_TLeafL),G__get_linked_tagnum(&G__G__TreeLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__TreeLN_TLeafObject))) {
     TLeafObject *G__Lderived;
     G__Lderived=(TLeafObject*)0x1000;
     {
       TLeaf *G__Lpbase=(TLeaf*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TreeLN_TLeafObject),G__get_linked_tagnum(&G__G__TreeLN_TLeaf),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TreeLN_TLeafObject),G__get_linked_tagnum(&G__G__TreeLN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TreeLN_TLeafObject),G__get_linked_tagnum(&G__G__TreeLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__TreeLN_TLeafO))) {
     TLeafO *G__Lderived;
     G__Lderived=(TLeafO*)0x1000;
     {
       TLeaf *G__Lpbase=(TLeaf*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TreeLN_TLeafO),G__get_linked_tagnum(&G__G__TreeLN_TLeaf),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TreeLN_TLeafO),G__get_linked_tagnum(&G__G__TreeLN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TreeLN_TLeafO),G__get_linked_tagnum(&G__G__TreeLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__TreeLN_TLeafS))) {
     TLeafS *G__Lderived;
     G__Lderived=(TLeafS*)0x1000;
     {
       TLeaf *G__Lpbase=(TLeaf*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TreeLN_TLeafS),G__get_linked_tagnum(&G__G__TreeLN_TLeaf),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TreeLN_TLeafS),G__get_linked_tagnum(&G__G__TreeLN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TreeLN_TLeafS),G__get_linked_tagnum(&G__G__TreeLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__TreeLN_TNtupleD))) {
     TNtupleD *G__Lderived;
     G__Lderived=(TNtupleD*)0x1000;
     {
       TTree *G__Lpbase=(TTree*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TreeLN_TNtupleD),G__get_linked_tagnum(&G__G__TreeLN_TTree),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TreeLN_TNtupleD),G__get_linked_tagnum(&G__G__TreeLN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TreeLN_TNtupleD),G__get_linked_tagnum(&G__G__TreeLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TAttLine *G__Lpbase=(TAttLine*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TreeLN_TNtupleD),G__get_linked_tagnum(&G__G__TreeLN_TAttLine),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TAttFill *G__Lpbase=(TAttFill*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TreeLN_TNtupleD),G__get_linked_tagnum(&G__G__TreeLN_TAttFill),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TAttMarker *G__Lpbase=(TAttMarker*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TreeLN_TNtupleD),G__get_linked_tagnum(&G__G__TreeLN_TAttMarker),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__TreeLN_TNtuple))) {
     TNtuple *G__Lderived;
     G__Lderived=(TNtuple*)0x1000;
     {
       TTree *G__Lpbase=(TTree*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TreeLN_TNtuple),G__get_linked_tagnum(&G__G__TreeLN_TTree),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TreeLN_TNtuple),G__get_linked_tagnum(&G__G__TreeLN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TreeLN_TNtuple),G__get_linked_tagnum(&G__G__TreeLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TAttLine *G__Lpbase=(TAttLine*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TreeLN_TNtuple),G__get_linked_tagnum(&G__G__TreeLN_TAttLine),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TAttFill *G__Lpbase=(TAttFill*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TreeLN_TNtuple),G__get_linked_tagnum(&G__G__TreeLN_TAttFill),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TAttMarker *G__Lpbase=(TAttMarker*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TreeLN_TNtuple),G__get_linked_tagnum(&G__G__TreeLN_TAttMarker),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__TreeLN_TQueryResult))) {
     TQueryResult *G__Lderived;
     G__Lderived=(TQueryResult*)0x1000;
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TreeLN_TQueryResult),G__get_linked_tagnum(&G__G__TreeLN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TreeLN_TQueryResult),G__get_linked_tagnum(&G__G__TreeLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__TreeLN_TSelectorList))) {
     TSelectorList *G__Lderived;
     G__Lderived=(TSelectorList*)0x1000;
     {
       TList *G__Lpbase=(TList*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TreeLN_TSelectorList),G__get_linked_tagnum(&G__G__TreeLN_TList),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TSeqCollection *G__Lpbase=(TSeqCollection*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TreeLN_TSelectorList),G__get_linked_tagnum(&G__G__TreeLN_TSeqCollection),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TCollection *G__Lpbase=(TCollection*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TreeLN_TSelectorList),G__get_linked_tagnum(&G__G__TreeLN_TCollection),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TreeLN_TSelectorList),G__get_linked_tagnum(&G__G__TreeLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__TreeLN_TSelectorCint))) {
     TSelectorCint *G__Lderived;
     G__Lderived=(TSelectorCint*)0x1000;
     {
       TSelector *G__Lpbase=(TSelector*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TreeLN_TSelectorCint),G__get_linked_tagnum(&G__G__TreeLN_TSelector),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TreeLN_TSelectorCint),G__get_linked_tagnum(&G__G__TreeLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__TreeLN_TSelectorScalar))) {
     TSelectorScalar *G__Lderived;
     G__Lderived=(TSelectorScalar*)0x1000;
     {
       TParameter<long long> *G__Lpbase=(TParameter<long long>*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TreeLN_TSelectorScalar),G__get_linked_tagnum(&G__G__TreeLN_TParameterlElongsPlonggR),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TreeLN_TSelectorScalar),G__get_linked_tagnum(&G__G__TreeLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__TreeLN_TParameterlElongsPlonggR))) {
     TParameter<long long> *G__Lderived;
     G__Lderived=(TParameter<long long>*)0x1000;
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TreeLN_TParameterlElongsPlonggR),G__get_linked_tagnum(&G__G__TreeLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__TreeLN_TTreeCache))) {
     TTreeCache *G__Lderived;
     G__Lderived=(TTreeCache*)0x1000;
     {
       TFileCacheRead *G__Lpbase=(TFileCacheRead*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TreeLN_TTreeCache),G__get_linked_tagnum(&G__G__TreeLN_TFileCacheRead),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TreeLN_TTreeCache),G__get_linked_tagnum(&G__G__TreeLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__TreeLN_TTreeCacheUnzip))) {
     TTreeCacheUnzip *G__Lderived;
     G__Lderived=(TTreeCacheUnzip*)0x1000;
     {
       TTreeCache *G__Lpbase=(TTreeCache*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TreeLN_TTreeCacheUnzip),G__get_linked_tagnum(&G__G__TreeLN_TTreeCache),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TFileCacheRead *G__Lpbase=(TFileCacheRead*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TreeLN_TTreeCacheUnzip),G__get_linked_tagnum(&G__G__TreeLN_TFileCacheRead),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TreeLN_TTreeCacheUnzip),G__get_linked_tagnum(&G__G__TreeLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__TreeLN_TTreeResult))) {
     TTreeResult *G__Lderived;
     G__Lderived=(TTreeResult*)0x1000;
     {
       TSQLResult *G__Lpbase=(TSQLResult*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TreeLN_TTreeResult),G__get_linked_tagnum(&G__G__TreeLN_TSQLResult),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TreeLN_TTreeResult),G__get_linked_tagnum(&G__G__TreeLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__TreeLN_TTreeRow))) {
     TTreeRow *G__Lderived;
     G__Lderived=(TTreeRow*)0x1000;
     {
       TSQLRow *G__Lpbase=(TSQLRow*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TreeLN_TTreeRow),G__get_linked_tagnum(&G__G__TreeLN_TSQLRow),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TreeLN_TTreeRow),G__get_linked_tagnum(&G__G__TreeLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__TreeLN_TTreeSQL))) {
     TTreeSQL *G__Lderived;
     G__Lderived=(TTreeSQL*)0x1000;
     {
       TTree *G__Lpbase=(TTree*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TreeLN_TTreeSQL),G__get_linked_tagnum(&G__G__TreeLN_TTree),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TreeLN_TTreeSQL),G__get_linked_tagnum(&G__G__TreeLN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TreeLN_TTreeSQL),G__get_linked_tagnum(&G__G__TreeLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TAttLine *G__Lpbase=(TAttLine*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TreeLN_TTreeSQL),G__get_linked_tagnum(&G__G__TreeLN_TAttLine),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TAttFill *G__Lpbase=(TAttFill*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TreeLN_TTreeSQL),G__get_linked_tagnum(&G__G__TreeLN_TAttFill),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TAttMarker *G__Lpbase=(TAttMarker*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TreeLN_TTreeSQL),G__get_linked_tagnum(&G__G__TreeLN_TAttMarker),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
}

/*********************************************************
* typedef information setup/
*********************************************************/
extern "C" void G__cpp_setup_typetableG__Tree() {

   /* Setting up typedef entry */
   G__search_typename2("Char_t",99,-1,0,-1);
   G__setnewtype(-1,"Signed Character 1 byte (char)",0);
   G__search_typename2("UChar_t",98,-1,0,-1);
   G__setnewtype(-1,"Unsigned Character 1 byte (unsigned char)",0);
   G__search_typename2("Int_t",105,-1,0,-1);
   G__setnewtype(-1,"Signed integer 4 bytes (int)",0);
   G__search_typename2("UInt_t",104,-1,0,-1);
   G__setnewtype(-1,"Unsigned integer 4 bytes (unsigned int)",0);
   G__search_typename2("Long_t",108,-1,0,-1);
   G__setnewtype(-1,"Signed long integer 4 bytes (long)",0);
   G__search_typename2("Float_t",102,-1,0,-1);
   G__setnewtype(-1,"Float 4 bytes (float)",0);
   G__search_typename2("Double_t",100,-1,0,-1);
   G__setnewtype(-1,"Double 8 bytes",0);
   G__search_typename2("Bool_t",103,-1,0,-1);
   G__setnewtype(-1,"Boolean (0=false, 1=true) (bool)",0);
   G__search_typename2("Version_t",115,-1,0,-1);
   G__setnewtype(-1,"Class version identifier (short)",0);
   G__search_typename2("Option_t",99,-1,256,-1);
   G__setnewtype(-1,"Option string (const char)",0);
   G__search_typename2("Long64_t",110,-1,0,-1);
   G__setnewtype(-1,"Portable signed long integer 8 bytes",0);
   G__search_typename2("ULong64_t",109,-1,0,-1);
   G__setnewtype(-1,"Portable unsigned long integer 8 bytes",0);
   G__search_typename2("vector<ROOT::TSchemaHelper>",117,G__get_linked_tagnum(&G__G__TreeLN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__TreeLN_reverse_iteratorlEvectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TreeLN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__TreeLN_reverse_iteratorlEvectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TreeLN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<TVirtualArray*>",117,G__get_linked_tagnum(&G__G__TreeLN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__TreeLN_reverse_iteratorlEvectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TreeLN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__TreeLN_reverse_iteratorlEvectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TreeLN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<Int_t>",117,G__get_linked_tagnum(&G__G__TreeLN_vectorlEintcOallocatorlEintgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__TreeLN_reverse_iteratorlEvectorlEintcOallocatorlEintgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TreeLN_vectorlEintcOallocatorlEintgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__TreeLN_reverse_iteratorlEvectorlEintcOallocatorlEintgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TreeLN_vectorlEintcOallocatorlEintgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<int>",117,G__get_linked_tagnum(&G__G__TreeLN_vectorlEintcOallocatorlEintgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("iterator<std::bidirectional_iterator_tag,TObject*,std::ptrdiff_t,const TObject**,const TObject*&>",117,G__get_linked_tagnum(&G__G__TreeLN_iteratorlEbidirectional_iterator_tagcOTObjectmUcOlongcOconstsPTObjectmUmUcOconstsPTObjectmUaNgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("iterator<bidirectional_iterator_tag,TObject*>",117,G__get_linked_tagnum(&G__G__TreeLN_iteratorlEbidirectional_iterator_tagcOTObjectmUcOlongcOconstsPTObjectmUmUcOconstsPTObjectmUaNgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("iterator<bidirectional_iterator_tag,TObject*,long>",117,G__get_linked_tagnum(&G__G__TreeLN_iteratorlEbidirectional_iterator_tagcOTObjectmUcOlongcOconstsPTObjectmUmUcOconstsPTObjectmUaNgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("iterator<bidirectional_iterator_tag,TObject*,long,const TObject**>",117,G__get_linked_tagnum(&G__G__TreeLN_iteratorlEbidirectional_iterator_tagcOTObjectmUcOlongcOconstsPTObjectmUmUcOconstsPTObjectmUaNgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("MethodCreateListOfBrowsables_t",89,-1,0,G__get_linked_tagnum(&G__G__TreeLN_TVirtualBranchBrowsable));
   G__setnewtype(-1,"Int_t (*MethodCreateListOfBrowsables_t)",0);
   G__search_typename2("list<MethodCreateListOfBrowsables_t>",117,G__get_linked_tagnum(&G__G__TreeLN_listlEvoidmUcOallocatorlEvoidmUgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("list<void*>",117,G__get_linked_tagnum(&G__G__TreeLN_listlEvoidmUcOallocatorlEvoidmUgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("ClassInfo_t",121,-1,0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("ReadLeaves_t",97,-1,0,G__get_linked_tagnum(&G__G__TreeLN_TBranch));
   G__setnewtype(-1,"void (TBranch::*ReadLeaves_t)(TBuffer &b);",0);
   G__search_typename2("map<std::string,TObjArray*>",117,G__get_linked_tagnum(&G__G__TreeLN_maplEstringcOTObjArraymUcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOTObjArraymUgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<string,TObjArray*>",117,G__get_linked_tagnum(&G__G__TreeLN_maplEstringcOTObjArraymUcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOTObjArraymUgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<string,TObjArray*,less<string> >",117,G__get_linked_tagnum(&G__G__TreeLN_maplEstringcOTObjArraymUcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOTObjArraymUgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<std::string>",117,G__get_linked_tagnum(&G__G__TreeLN_vectorlEstringcOallocatorlEstringgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__TreeLN_reverse_iteratorlEvectorlEstringcOallocatorlEstringgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TreeLN_vectorlEstringcOallocatorlEstringgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__TreeLN_reverse_iteratorlEvectorlEstringcOallocatorlEstringgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TreeLN_vectorlEstringcOallocatorlEstringgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<string>",117,G__get_linked_tagnum(&G__G__TreeLN_vectorlEstringcOallocatorlEstringgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<TStreamerInfo*>",117,G__get_linked_tagnum(&G__G__TreeLN_vectorlETStreamerInfomUcOallocatorlETStreamerInfomUgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__TreeLN_reverse_iteratorlEvectorlETStreamerInfomUcOallocatorlETStreamerInfomUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TreeLN_vectorlETStreamerInfomUcOallocatorlETStreamerInfomUgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__TreeLN_reverse_iteratorlEvectorlETStreamerInfomUcOallocatorlETStreamerInfomUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TreeLN_vectorlETStreamerInfomUcOallocatorlETStreamerInfomUgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TParameter<Long64_t>",117,G__get_linked_tagnum(&G__G__TreeLN_TParameterlElongsPlonggR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("deque<int>",117,G__get_linked_tagnum(&G__G__TreeLN_dequelEintcOallocatorlEintgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("queue<Int_t>",117,G__get_linked_tagnum(&G__G__TreeLN_queuelEintcOdequelEintcOallocatorlEintgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("queue<int>",117,G__get_linked_tagnum(&G__G__TreeLN_queuelEintcOdequelEintcOallocatorlEintgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
}

/*********************************************************
* Data Member information setup/
*********************************************************/

   /* Setting up class,struct,union tag member variable */

   /* TTree */
static void G__setup_memvarTTree(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__TreeLN_TTree));
   { TTree *p; p=(TTree*)0x1000; if (p) { }
   G__memvar_setup((void*)0,110,0,0,-1,G__defined_typename("Long64_t"),-1,2,"fEntries=",0,"Number of entries");
   G__memvar_setup((void*)0,110,0,0,-1,G__defined_typename("Long64_t"),-1,2,"fTotBytes=",0,"Total number of bytes in all branches before compression");
   G__memvar_setup((void*)0,110,0,0,-1,G__defined_typename("Long64_t"),-1,2,"fZipBytes=",0,"Total number of bytes in all branches after compression");
   G__memvar_setup((void*)0,110,0,0,-1,G__defined_typename("Long64_t"),-1,2,"fSavedBytes=",0,"Number of autosaved bytes");
   G__memvar_setup((void*)0,110,0,0,-1,G__defined_typename("Long64_t"),-1,2,"fFlushedBytes=",0,"Number of autoflushed bytes");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fWeight=",0,"Tree weight (see TTree::SetWeight)");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fTimerInterval=",0,"Timer interval in milliseconds");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fScanField=",0,"Number of runs before prompting in Scan");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fUpdate=",0,"Update frequency for EntryLoop");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fDefaultEntryOffsetLen=",0,"Initial Length of fEntryOffset table in the basket buffers");
   G__memvar_setup((void*)0,110,0,0,-1,G__defined_typename("Long64_t"),-1,2,"fMaxEntries=",0,"Maximum number of entries in case of circular buffers");
   G__memvar_setup((void*)0,110,0,0,-1,G__defined_typename("Long64_t"),-1,2,"fMaxEntryLoop=",0,"Maximum number of entries to process");
   G__memvar_setup((void*)0,110,0,0,-1,G__defined_typename("Long64_t"),-1,2,"fMaxVirtualSize=",0,"Maximum total size of buffers kept in memory");
   G__memvar_setup((void*)0,110,0,0,-1,G__defined_typename("Long64_t"),-1,2,"fAutoSave=",0,"Autosave tree when fAutoSave bytes produced");
   G__memvar_setup((void*)0,110,0,0,-1,G__defined_typename("Long64_t"),-1,2,"fAutoFlush=",0,"Autoflush tree when fAutoFlush entries written");
   G__memvar_setup((void*)0,110,0,0,-1,G__defined_typename("Long64_t"),-1,2,"fEstimate=",0,"Number of entries to estimate histogram limits");
   G__memvar_setup((void*)0,110,0,0,-1,G__defined_typename("Long64_t"),-1,2,"fCacheSize=",0,"! Maximum size of file buffers");
   G__memvar_setup((void*)0,110,0,0,-1,G__defined_typename("Long64_t"),-1,2,"fChainOffset=",0,"! Offset of 1st entry of this Tree in a TChain");
   G__memvar_setup((void*)0,110,0,0,-1,G__defined_typename("Long64_t"),-1,2,"fReadEntry=",0,"! Number of the entry being processed");
   G__memvar_setup((void*)0,110,0,0,-1,G__defined_typename("Long64_t"),-1,2,"fTotalBuffers=",0,"! Total number of bytes in branch buffers");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fPacketSize=",0,"! Number of entries in one packet for parallel root");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fNfill=",0,"! Local for EntryLoop");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fDebug=",0,"! Debug level");
   G__memvar_setup((void*)0,110,0,0,-1,G__defined_typename("Long64_t"),-1,2,"fDebugMin=",0,"! First entry number to debug");
   G__memvar_setup((void*)0,110,0,0,-1,G__defined_typename("Long64_t"),-1,2,"fDebugMax=",0,"! Last entry number to debug");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fMakeClass=",0,"! not zero when processing code generated by MakeClass");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fFileNumber=",0,"! current file number (if file extensions)");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TreeLN_TObject),-1,-1,2,"fNotify=",0,"! Object to be notified when loading a Tree");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TreeLN_TDirectory),-1,-1,2,"fDirectory=",0,"! Pointer to directory holding this tree");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TreeLN_TObjArray),-1,-1,2,"fBranches=",0,"List of Branches");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TreeLN_TObjArray),-1,-1,2,"fLeaves=",0,"Direct pointers to individual branch leaves");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TreeLN_TList),-1,-1,2,"fAliases=",0,"List of aliases for expressions based on the tree branches.");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TreeLN_TEventList),-1,-1,2,"fEventList=",0,"! Pointer to event selection list (if one)");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TreeLN_TEntryList),-1,-1,2,"fEntryList=",0,"! Pointer to event selection list (if one)");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TreeLN_TArrayD),-1,-1,2,"fIndexValues=",0,"Sorted index values");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TreeLN_TArrayI),-1,-1,2,"fIndex=",0,"Index of sorted values");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TreeLN_TVirtualIndex),-1,-1,2,"fTreeIndex=",0,"Pointer to the tree Index (if any)");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TreeLN_TList),-1,-1,2,"fFriends=",0,"pointer to list of friend elements");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TreeLN_TList),-1,-1,2,"fUserInfo=",0,"pointer to a list of user objects associated to this Tree");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TreeLN_TVirtualTreePlayer),-1,-1,2,"fPlayer=",0,"! Pointer to current Tree player");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TreeLN_TList),-1,-1,2,"fClones=",0,"! List of cloned trees which share our addresses");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TreeLN_TBranchRef),-1,-1,2,"fBranchRef=",0,"Branch supporting the TRefTable (if any)");
   G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,2,"fFriendLockStatus=",0,"! Record which method is locking the friend recursion");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-2,2,"fgBranchStyle=",0,"Old/New branch style");
   G__memvar_setup((void*)0,110,0,0,-1,G__defined_typename("Long64_t"),-2,2,"fgMaxTreeSize=",0,"Maximum size of a file containg a Tree");
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TreeLN_TTreecLcLELockStatusBits),-1,-2,2,"kFindBranch=1LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TreeLN_TTreecLcLELockStatusBits),-1,-2,2,"kFindLeaf=2LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TreeLN_TTreecLcLELockStatusBits),-1,-2,2,"kGetAlias=4LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TreeLN_TTreecLcLELockStatusBits),-1,-2,2,"kGetBranch=8LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TreeLN_TTreecLcLELockStatusBits),-1,-2,2,"kGetEntry=16LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TreeLN_TTreecLcLELockStatusBits),-1,-2,2,"kGetEntryWithIndex=32LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TreeLN_TTreecLcLELockStatusBits),-1,-2,2,"kGetFriend=64LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TreeLN_TTreecLcLELockStatusBits),-1,-2,2,"kGetFriendAlias=128LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TreeLN_TTreecLcLELockStatusBits),-1,-2,2,"kGetLeaf=256LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TreeLN_TTreecLcLELockStatusBits),-1,-2,2,"kLoadTree=512LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TreeLN_TTreecLcLELockStatusBits),-1,-2,2,"kPrint=1024LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TreeLN_TTreecLcLELockStatusBits),-1,-2,2,"kRemoveFriend=2048LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TreeLN_TTreecLcLELockStatusBits),-1,-2,2,"kSetBranchStatus=4096LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TreeLN_TTreecLcLSetBranchAddressStatus),-1,-2,2,"kMissingBranch=-5LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TreeLN_TTreecLcLSetBranchAddressStatus),-1,-2,2,"kInternalError=-4LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TreeLN_TTreecLcLSetBranchAddressStatus),-1,-2,2,"kMissingCompiledCollectionProxy=-3LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TreeLN_TTreecLcLSetBranchAddressStatus),-1,-2,2,"kMismatch=-2LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TreeLN_TTreecLcLSetBranchAddressStatus),-1,-2,2,"kClassMismatch=-1LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TreeLN_TTreecLcLSetBranchAddressStatus),-1,-2,2,"kMatch=0LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TreeLN_TTreecLcLSetBranchAddressStatus),-1,-2,2,"kMatchConversion=1LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TreeLN_TTreecLcLSetBranchAddressStatus),-1,-2,2,"kMatchConversionCollection=2LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TreeLN_TTreecLcLSetBranchAddressStatus),-1,-2,2,"kMakeClass=3LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TreeLN_TTreecLcLSetBranchAddressStatus),-1,-2,2,"kVoidPtr=4LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TreeLN_TTreecLcLSetBranchAddressStatus),-1,-2,2,"kNoCheck=5LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TreeLN_TTreecLcLdA),-1,-2,1,G__FastAllocString(2048).Format("kForceRead=%lldLL",(long long)TTree::kForceRead).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TreeLN_TTreecLcLdA),-1,-2,1,G__FastAllocString(2048).Format("kCircular=%lldLL",(long long)TTree::kCircular).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TreeLN_TTreecLcLdA),-1,-2,1,G__FastAllocString(2048).Format("kSplitCollectionOfPointers=%lldLL",(long long)TTree::kSplitCollectionOfPointers).data(),0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TreeLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TBranch */
static void G__setup_memvarTBranch(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__TreeLN_TBranch));
   { TBranch *p; p=(TBranch*)0x1000; if (p) { }
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TreeLN_TBranchcLcLdA),-1,-2,2,"kAutoDelete=32768LL",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-2,2,"fgCount=",0,"! branch counter");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fCompress=",0,"(=1 branch is compressed, 0 otherwise)");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fBasketSize=",0,"Initial Size of  Basket Buffer");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fEntryOffsetLen=",0,"Initial Length of fEntryOffset table in the basket buffers");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fWriteBasket=",0,"Last basket number written");
   G__memvar_setup((void*)0,110,0,0,-1,G__defined_typename("Long64_t"),-1,2,"fEntryNumber=",0,"Current entry number (last one filled in this branch)");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fOffset=",0,"Offset of this branch");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fMaxBaskets=",0,"Maximum number of Baskets so far");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fNBaskets=",0,"! Number of baskets in memory");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fSplitLevel=",0,"Branch split level");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fNleaves=",0,"! Number of leaves");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fReadBasket=",0,"! Current basket number when reading");
   G__memvar_setup((void*)0,110,0,0,-1,G__defined_typename("Long64_t"),-1,2,"fReadEntry=",0,"! Current entry number when reading");
   G__memvar_setup((void*)0,110,0,0,-1,G__defined_typename("Long64_t"),-1,2,"fEntries=",0,"Number of entries");
   G__memvar_setup((void*)0,110,0,0,-1,G__defined_typename("Long64_t"),-1,2,"fFirstEntry=",0,"Number of the first entry in this branch");
   G__memvar_setup((void*)0,110,0,0,-1,G__defined_typename("Long64_t"),-1,2,"fTotBytes=",0,"Total number of bytes in all leaves before compression");
   G__memvar_setup((void*)0,110,0,0,-1,G__defined_typename("Long64_t"),-1,2,"fZipBytes=",0,"Total number of bytes in all leaves after compression");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TreeLN_TObjArray),-1,-1,2,"fBranches=",0,"-> List of Branches of this branch");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TreeLN_TObjArray),-1,-1,2,"fLeaves=",0,"-> List of leaves of this branch");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TreeLN_TObjArray),-1,-1,2,"fBaskets=",0,"-> List of baskets of this branch");
   G__memvar_setup((void*)0,73,0,0,-1,G__defined_typename("Int_t"),-1,2,"fBasketBytes=",0,"[fMaxBaskets] Lenght of baskets on file");
   G__memvar_setup((void*)0,78,0,0,-1,G__defined_typename("Long64_t"),-1,2,"fBasketEntry=",0,"[fMaxBaskets] Table of first entry in eack basket");
   G__memvar_setup((void*)0,78,0,0,-1,G__defined_typename("Long64_t"),-1,2,"fBasketSeek=",0,"[fMaxBaskets] Addresses of baskets on file");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TreeLN_TTree),-1,-1,2,"fTree=",0,"! Pointer to Tree header");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TreeLN_TBranch),-1,-1,2,"fMother=",0,"! Pointer to top-level parent branch in the tree.");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TreeLN_TBranch),-1,-1,2,"fParent=",0,"! Pointer to parent branch.");
   G__memvar_setup((void*)0,67,0,0,-1,-1,-1,2,"fAddress=",0,"! Address of 1st leaf (variable or object)");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TreeLN_TDirectory),-1,-1,2,"fDirectory=",0,"! Pointer to directory where this branch buffers are stored");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TreeLN_TString),-1,-1,2,"fFileName=",0,"Name of file where buffers are stored (\"\" if in same file as Tree header)");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TreeLN_TBuffer),-1,-1,2,"fEntryBuffer=",0,"! Buffer used to directly pass the content without streaming");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TreeLN_TList),-1,-1,2,"fBrowsables=",0,"! List of TVirtualBranchBrowsables used for Browse()");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fSkipZip=",0,"! After being read, the buffer will not be unziped.");
   G__memvar_setup((void*)0,97,0,0,-1,G__defined_typename("ReadLeaves_t"),-1,2,"fReadLeaves=",0,"! Pointer to the ReadLeaves implementation to use. ");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TreeLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TBasket */
static void G__setup_memvarTBasket(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__TreeLN_TBasket));
   { TBasket *p; p=(TBasket*)0x1000; if (p) { }
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fBufferSize=",0,"fBuffer length in bytes");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fNevBufSize=",0,"Length in Int_t of fEntryOffset OR fixed length of each entry if fEntryOffset is null!");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fNevBuf=",0,"Number of entries in basket");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fLast=",0,"Pointer to last used byte in basket");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fHeaderOnly=",0,"True when only the basket header must be read/written");
   G__memvar_setup((void*)0,73,0,0,-1,G__defined_typename("Int_t"),-1,2,"fDisplacement=",0,"![fNevBuf] Displacement of entries in fBuffer(TKey)");
   G__memvar_setup((void*)0,73,0,0,-1,G__defined_typename("Int_t"),-1,2,"fEntryOffset=",0,"[fNevBuf] Offset of entries in fBuffer(TKey)");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TreeLN_TBranch),-1,-1,2,"fBranch=",0,"Pointer to the basket support branch");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fCompressedSize=",0,"!Size of the allocated memroy in fCompressedBuffer");
   G__memvar_setup((void*)0,67,0,0,-1,-1,-1,2,"fCompressedBuffer=",0,"!Temporary place holder for the compressed buffer if needed.");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TreeLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TBufferSQL */
static void G__setup_memvarTBufferSQL(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__TreeLN_TBufferSQL));
   { TBufferSQL *p; p=(TBufferSQL*)0x1000; if (p) { }
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TreeLN_vectorlEintcOallocatorlEintgRsPgRcLcLiterator),G__defined_typename("const_iterator"),-1,4,"fIter=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TreeLN_vectorlEintcOallocatorlEintgRsPgR),G__defined_typename("vector<Int_t>"),-1,4,"fColumnVec=",0,"!");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TreeLN_TString),-1,-1,4,"fInsertQuery=",0,"!");
   G__memvar_setup((void*)0,85,2,0,G__get_linked_tagnum(&G__G__TreeLN_TSQLRow),-1,-1,4,"fRowPtr=",0,"!");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TreeLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TBasketSQL */
static void G__setup_memvarTBasketSQL(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__TreeLN_TBasketSQL));
   { TBasketSQL *p; p=(TBasketSQL*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,2,0,G__get_linked_tagnum(&G__G__TreeLN_TSQLResult),-1,-1,2,"fResultPtr=",0,"!");
   G__memvar_setup((void*)0,85,2,0,G__get_linked_tagnum(&G__G__TreeLN_TSQLRow),-1,-1,2,"fRowPtr=",0,"!");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TreeLN_TString),-1,-1,2,"fInsertQuery=",0,"!");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TreeLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TBranchElement */
static void G__setup_memvarTBranchElement(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__TreeLN_TBranchElement));
   { TBranchElement *p; p=(TBranchElement*)0x1000; if (p) { }
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TreeLN_TBranchElementcLcLdA),-1,-2,2,"kBranchFolder=16384LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TreeLN_TBranchElementcLcLdA),-1,-2,2,"kDeleteObject=65536LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TreeLN_TBranchElementcLcLdA),-1,-2,2,"kCache=262144LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TreeLN_TBranchElementcLcLdA),-1,-2,2,"kOwnOnfileObj=524288LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TreeLN_TBranchElementcLcLdA),-1,-2,2,"kAddressSet=1048576LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TreeLN_TBranchElementcLcLdA),-1,-2,2,"kMakeClass=2097152LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TreeLN_TBranchElementcLcLdA),-1,-2,2,"kDecomposedObj=2097152LL",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TreeLN_TString),-1,-1,2,"fClassName=",0,"Class name of referenced object");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TreeLN_TString),-1,-1,2,"fParentName=",0,"Name of parent class");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TreeLN_TString),-1,-1,2,"fClonesName=",0,"Name of class in TClonesArray (if any)");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TreeLN_TVirtualCollectionProxy),-1,-1,2,"fCollProxy=",0,"! collection interface (if any)");
   G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,2,"fCheckSum=",0,"CheckSum of class");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fClassVersion=",0,"Version number of class");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fID=",0,"element serial number in fInfo");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fType=",0,"branch type");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fStreamerType=",0,"branch streamer type");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fMaximum=",0,"Maximum entries for a TClonesArray or variable array");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fSTLtype=",0,"! STL container type");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fNdata=",0,"! Number of data in this branch");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TreeLN_TBranchElement),-1,-1,2,"fBranchCount=",0,"pointer to primary branchcount branch");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TreeLN_TBranchElement),-1,-1,2,"fBranchCount2=",0,"pointer to secondary branchcount branch");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TreeLN_TStreamerInfo),-1,-1,2,"fInfo=",0,"! Pointer to StreamerInfo");
   G__memvar_setup((void*)0,67,0,0,-1,-1,-1,2,"fObject=",0,"! Pointer to object at *fAddress");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TreeLN_TVirtualArray),-1,-1,2,"fOnfileObject=",0,"! Place holder for the onfile representation of data members.");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fInit=",0,"! Initialization flag for branch assignment");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fInitOffsets=",0,"! Initialization flag to not endlessly recalculate offsets");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TreeLN_TClassRef),-1,-1,2,"fTargetClass=",0,"! Reference to the target in-memory class");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TreeLN_TClassRef),-1,-1,2,"fCurrentClass=",0,"! Reference to current (transient) class definition");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TreeLN_TClassRef),-1,-1,2,"fParentClass=",0,"! Reference to class definition in fParentName");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TreeLN_TClassRef),-1,-1,2,"fBranchClass=",0,"! Reference to class definition in fClassName");
   G__memvar_setup((void*)0,73,0,0,-1,G__defined_typename("Int_t"),-1,2,"fBranchOffset=",0,"! Sub-Branch offsets with respect to current transient class");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fBranchID=",0,"! ID number assigned by a TRefTable.");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TreeLN_vectorlEintcOallocatorlEintgRsPgR),G__defined_typename("vector<Int_t>"),-1,2,"fIDs=",0,"! List of the serial number of all the StreamerInfo to be used.   ");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TreeLN_TStreamerInfoActionscLcLTActionSequence),-1,-1,2,"fReadActionSequence=",0,"! Set of actions to be executed to extract the data from the basket.");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TreeLN_TVirtualCollectionIterators),-1,-1,2,"fIterators=",0,"! holds the iterators when the branch is of fType==4.");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TreeLN_TVirtualCollectionPtrIterators),-1,-1,2,"fPtrIterators=",0,"! holds the iterators when the branch is of fType==4 and it is a split collection of pointers.");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TreeLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TVirtualBranchBrowsable */
static void G__setup_memvarTVirtualBranchBrowsable(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__TreeLN_TVirtualBranchBrowsable));
   { TVirtualBranchBrowsable *p; p=(TVirtualBranchBrowsable*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,1,G__get_linked_tagnum(&G__G__TreeLN_TBranch),-1,-1,4,"fBranch=",0,"pointer to the branch element representing the top object");
   G__memvar_setup((void*)0,85,0,1,G__get_linked_tagnum(&G__G__TreeLN_TVirtualBranchBrowsable),-1,-1,4,"fParent=",0,"parent method if this method is member of a returned class");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TreeLN_TList),-1,-1,4,"fLeaves=",0,"pointer to laves");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TreeLN_TClass),-1,-1,4,"fClass=",0,"pointer to TClass representing our type (i.e. return type for methods), 0 if basic type");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fTypeIsPointer=",0,"return type is pointer to class");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TreeLN_listlEvoidmUcOallocatorlEvoidmUgRsPgR),G__defined_typename("list<MethodCreateListOfBrowsables_t>"),-2,4,"fgGenerators=",0,"list of MethodCreateListOfBrowsables_t called by CreateListOfBrowsables");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-2,4,"fgGeneratorsSet=",0,"have we set the generators yet? empty is not good enough - user might have removed them");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TreeLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TMethodBrowsable */
static void G__setup_memvarTMethodBrowsable(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__TreeLN_TMethodBrowsable));
   { TMethodBrowsable *p; p=(TMethodBrowsable*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TreeLN_TMethod),-1,-1,4,"fMethod=",0,"pointer to a method");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TreeLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TNonSplitBrowsable */
static void G__setup_memvarTNonSplitBrowsable(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__TreeLN_TNonSplitBrowsable));
   { TNonSplitBrowsable *p; p=(TNonSplitBrowsable*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TreeLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TCollectionPropertyBrowsable */
static void G__setup_memvarTCollectionPropertyBrowsable(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__TreeLN_TCollectionPropertyBrowsable));
   { TCollectionPropertyBrowsable *p; p=(TCollectionPropertyBrowsable*)0x1000; if (p) { }
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TreeLN_TString),-1,-1,4,"fDraw=",0,"string to send to TTree::Draw(), NOT by GetScope()!");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TreeLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TCollectionMethodBrowsable */
static void G__setup_memvarTCollectionMethodBrowsable(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__TreeLN_TCollectionMethodBrowsable));
   { TCollectionMethodBrowsable *p; p=(TCollectionMethodBrowsable*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TreeLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TLeaf */
static void G__setup_memvarTLeaf(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__TreeLN_TLeaf));
   { TLeaf *p; p=(TLeaf*)0x1000; if (p) { }
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fNdata=",0,"! Number of elements in fAddress data buffer");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fLen=",0,"Number of fixed length elements");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fLenType=",0,"Number of bytes for this data type");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fOffset=",0,"Offset in ClonesArray object (if one)");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fIsRange=",0,"(=kTRUE if leaf has a range, kFALSE otherwise)");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fIsUnsigned=",0,"(=kTRUE if unsigned, kFALSE otherwise)");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TreeLN_TLeaf),-1,-1,2,"fLeafCount=",0,"Pointer to Leaf count if variable length (we do not own the counter)");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TreeLN_TBranch),-1,-1,2,"fBranch=",0,"! Pointer to supporting branch (we do not own the branch)");
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TreeLN_TLeafcLcLdA),-1,-2,1,G__FastAllocString(2048).Format("kIndirectAddress=%lldLL",(long long)TLeaf::kIndirectAddress).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TreeLN_TLeafcLcLdA),-1,-2,1,G__FastAllocString(2048).Format("kNewValue=%lldLL",(long long)TLeaf::kNewValue).data(),0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TreeLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TTreeCloner */
static void G__setup_memvarTTreeCloner(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__TreeLN_TTreeCloner));
   { TTreeCloner *p; p=(TTreeCloner*)0x1000; if (p) { }
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TreeLN_TString),-1,-1,4,"fWarningMsg=",0,"Text of the error message lead to an 'invalid' state");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fIsValid=",0,(char*)NULL);
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fNeedConversion=",0,"True if the fast merge is not possible but a slow merge might possible.");
   G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,4,"fOptions=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TreeLN_TTree),-1,-1,4,"fFromTree=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TreeLN_TTree),-1,-1,4,"fToTree=",0,(char*)NULL);
   G__memvar_setup((void*)0,67,0,0,-1,G__defined_typename("Option_t"),-1,4,"fMethod=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TreeLN_TObjArray),-1,-1,4,"fFromBranches=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TreeLN_TObjArray),-1,-1,4,"fToBranches=",0,(char*)NULL);
   G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,4,"fMaxBaskets=",0,(char*)NULL);
   G__memvar_setup((void*)0,72,0,0,-1,G__defined_typename("UInt_t"),-1,4,"fBasketBranchNum=",0,"[fMaxBaskets] Index of the branch(es) of the basket.");
   G__memvar_setup((void*)0,72,0,0,-1,G__defined_typename("UInt_t"),-1,4,"fBasketNum=",0,"[fMaxBaskets] index of the basket within the branch.");
   G__memvar_setup((void*)0,78,0,0,-1,G__defined_typename("Long64_t"),-1,4,"fBasketSeek=",0,"[fMaxBaskets] list of basket position to be read.");
   G__memvar_setup((void*)0,78,0,0,-1,G__defined_typename("Long64_t"),-1,4,"fBasketEntry=",0,"[fMaxBaskets] list of basket start entries.");
   G__memvar_setup((void*)0,72,0,0,-1,G__defined_typename("UInt_t"),-1,4,"fBasketIndex=",0,"[fMaxBaskets] ordered list of basket indices to be written.");
   G__memvar_setup((void*)0,114,0,0,-1,G__defined_typename("UShort_t"),-1,4,"fPidOffset=",0,"Offset to be added to the copied key/basket.");
   G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,4,"fCloneMethod=",0,"Indicates which cloning method was selected.");
   G__memvar_setup((void*)0,110,0,0,-1,G__defined_typename("Long64_t"),-1,4,"fToStartEntries=",0,"Number of entries in the target tree before any addition.");
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TreeLN_TTreeClonercLcLECloneMethod),-1,-2,4,"kDefault=0LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TreeLN_TTreeClonercLcLECloneMethod),-1,-2,4,"kSortBasketsByBranch=1LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TreeLN_TTreeClonercLcLECloneMethod),-1,-2,4,"kSortBasketsByOffset=2LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TreeLN_TTreeClonercLcLECloneMethod),-1,-2,4,"kSortBasketsByEntry=3LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TreeLN_TTreeClonercLcLEClonerOptions),-1,-2,1,G__FastAllocString(2048).Format("kNone=%lldLL",(long long)TTreeCloner::kNone).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TreeLN_TTreeClonercLcLEClonerOptions),-1,-2,1,G__FastAllocString(2048).Format("kNoWarnings=%lldLL",(long long)TTreeCloner::kNoWarnings).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TreeLN_TTreeClonercLcLEClonerOptions),-1,-2,1,G__FastAllocString(2048).Format("kIgnoreMissingTopLevel=%lldLL",(long long)TTreeCloner::kIgnoreMissingTopLevel).data(),0,(char*)NULL);
   G__memvar_setup((void*)0,108,0,0,-1,-1,-1,4,"G__virtualinfo=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TreeLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TBranchClones */
static void G__setup_memvarTBranchClones(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__TreeLN_TBranchClones));
   { TBranchClones *p; p=(TBranchClones*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TreeLN_TClonesArray),-1,-1,2,"fList=",0,"!Pointer to the clonesarray");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fRead=",0,"!flag = 1 if clonesarray has been read");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fN=",0,"!Number of elements in ClonesArray");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fNdataMax=",0,"!Maximum value of fN");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TreeLN_TString),-1,-1,2,"fClassName=",0,"name of the class of the objets in the ClonesArray");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TreeLN_TBranch),-1,-1,2,"fBranchCount=",0,"Branch with clones count");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TreeLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TSelector */
static void G__setup_memvarTSelector(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__TreeLN_TSelector));
   { TSelector *p; p=(TSelector*)0x1000; if (p) { }
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TreeLN_TSelectorcLcLEAbort),-1,-2,1,G__FastAllocString(2048).Format("kContinue=%lldLL",(long long)TSelector::kContinue).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TreeLN_TSelectorcLcLEAbort),-1,-2,1,G__FastAllocString(2048).Format("kAbortProcess=%lldLL",(long long)TSelector::kAbortProcess).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TreeLN_TSelectorcLcLEAbort),-1,-2,1,G__FastAllocString(2048).Format("kAbortFile=%lldLL",(long long)TSelector::kAbortFile).data(),0,(char*)NULL);
   G__memvar_setup((void*)((G__G__TreeLN_TSelector_PR*)p)->G__OS_fStatus(),110,0,0,-1,G__defined_typename("Long64_t"),-1,2,"fStatus=",0,"selector status");
   G__memvar_setup((void*)((G__G__TreeLN_TSelector_PR*)p)->G__OS_fAbort(),105,0,0,G__get_linked_tagnum(&G__G__TreeLN_TSelectorcLcLEAbort),-1,-1,2,"fAbort=",0,"abort status");
   G__memvar_setup((void*)((G__G__TreeLN_TSelector_PR*)p)->G__OS_fOption(),117,0,0,G__get_linked_tagnum(&G__G__TreeLN_TString),-1,-1,2,"fOption=",0,"option given to TTree::Process");
   G__memvar_setup((void*)((G__G__TreeLN_TSelector_PR*)p)->G__OS_fObject(),85,0,0,G__get_linked_tagnum(&G__G__TreeLN_TObject),-1,-1,2,"fObject=",0,"current object if processing object (vs. TTree)");
   G__memvar_setup((void*)((G__G__TreeLN_TSelector_PR*)p)->G__OS_fInput(),85,0,0,G__get_linked_tagnum(&G__G__TreeLN_TList),-1,-1,2,"fInput=",0,"list of objects available during processing");
   G__memvar_setup((void*)((G__G__TreeLN_TSelector_PR*)p)->G__OS_fOutput(),85,0,0,G__get_linked_tagnum(&G__G__TreeLN_TSelectorList),-1,-1,2,"fOutput=",0,"list of objects created during processing");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TreeLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TVirtualIndex */
static void G__setup_memvarTVirtualIndex(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__TreeLN_TVirtualIndex));
   { TVirtualIndex *p; p=(TVirtualIndex*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TreeLN_TTree),-1,-1,2,"fTree=",0,"! pointer to Tree");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TreeLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TVirtualTreePlayer */
static void G__setup_memvarTVirtualTreePlayer(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__TreeLN_TVirtualTreePlayer));
   { TVirtualTreePlayer *p; p=(TVirtualTreePlayer*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TreeLN_TClass),-1,-2,4,"fgPlayer=",0,"Pointer to class of Tree player");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TreeLN_TVirtualTreePlayer),-1,-2,4,"fgCurrent=",0,"Pointer to current Tree player");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TreeLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TEventList */
static void G__setup_memvarTEventList(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__TreeLN_TEventList));
   { TEventList *p; p=(TEventList*)0x1000; if (p) { }
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fN=",0,"Number of elements in the list");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fSize=",0,"Size of array");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fDelta=",0,"Increment size");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fReapply=",0,"If true, TTree::Draw will 'reapply' the original cut");
   G__memvar_setup((void*)0,78,0,0,-1,G__defined_typename("Long64_t"),-1,2,"fList=",0,"[fN]Array of elements");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TreeLN_TDirectory),-1,-1,2,"fDirectory=",0,"! Pointer to directory holding this tree");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TreeLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TEntryList */
static void G__setup_memvarTEntryList(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__TreeLN_TEntryList));
   { TEntryList *p; p=(TEntryList*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TreeLN_TList),-1,-1,2,"fLists=",0,"a list of underlying entry lists for each tree of a chain");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TreeLN_TEntryList),-1,-1,2,"fCurrent=",0,"! currently filled entry list");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fNBlocks=",0,"number of TEntryListBlocks");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TreeLN_TObjArray),-1,-1,2,"fBlocks=",0,"blocks with indices of passing events (TEntryListBlocks)");
   G__memvar_setup((void*)0,110,0,0,-1,G__defined_typename("Long64_t"),-1,2,"fN=",0,"number of entries in the list");
   G__memvar_setup((void*)0,110,0,0,-1,G__defined_typename("Long64_t"),-1,2,"fEntriesToProcess=",0,"used on proof to set the number of entries to process in a packet");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TreeLN_TString),-1,-1,2,"fTreeName=",0,"name of the tree");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TreeLN_TString),-1,-1,2,"fFileName=",0,"name of the file, where the tree is");
   G__memvar_setup((void*)0,107,0,0,-1,G__defined_typename("ULong_t"),-1,2,"fStringHash=",0,"! Hash value of a string of treename and filename");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fTreeNumber=",0,"! the index of the tree in the chain (used when the entry");
   G__memvar_setup((void*)0,110,0,0,-1,G__defined_typename("Long64_t"),-1,2,"fLastIndexQueried=",0,"! used to optimize GetEntry() function from a loop ");
   G__memvar_setup((void*)0,110,0,0,-1,G__defined_typename("Long64_t"),-1,2,"fLastIndexReturned=",0,"! used to optimize GetEntry() function from a loop");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fShift=",0,"! true when some sub-lists don't correspond to trees");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TreeLN_TDirectory),-1,-1,2,"fDirectory=",0,"! Pointer to directory holding this tree");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fReapply=",0,"If true, TTree::Draw will 'reapply' the original cut");
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TreeLN_TEntryListcLcLdA),-1,-2,1,G__FastAllocString(2048).Format("kBlockSize=%lldLL",(long long)TEntryList::kBlockSize).data(),0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TreeLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TFriendElement */
static void G__setup_memvarTFriendElement(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__TreeLN_TFriendElement));
   { TFriendElement *p; p=(TFriendElement*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TreeLN_TTree),-1,-1,2,"fParentTree=",0,"!pointer to the parent TTree");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TreeLN_TTree),-1,-1,2,"fTree=",0,"!pointer to the TTree described by this element");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TreeLN_TFile),-1,-1,2,"fFile=",0,"!pointer to the file containing the friend TTree");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TreeLN_TString),-1,-1,2,"fTreeName=",0,"name of the friend TTree");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fOwnFile=",0,"true if file is managed by this class");
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TreeLN_TFriendElementcLcLdA),-1,-2,1,G__FastAllocString(2048).Format("kFromChain=%lldLL",(long long)TFriendElement::kFromChain).data(),0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TreeLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TCut */
static void G__setup_memvarTCut(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__TreeLN_TCut));
   { TCut *p; p=(TCut*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TreeLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TBranchRef */
static void G__setup_memvarTBranchRef(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__TreeLN_TBranchRef));
   { TBranchRef *p; p=(TBranchRef*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TreeLN_TRefTable),-1,-1,2,"fRefTable=",0,"pointer to the TRefTable");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TreeLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TTreeFriendLeafIter */
static void G__setup_memvarTTreeFriendLeafIter(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__TreeLN_TTreeFriendLeafIter));
   { TTreeFriendLeafIter *p; p=(TTreeFriendLeafIter*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TreeLN_TTree),-1,-1,2,"fTree=",0,"tree being iterated");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TreeLN_TIterator),-1,-1,2,"fLeafIter=",0,"current leaf sub-iterator.");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TreeLN_TIterator),-1,-1,2,"fTreeIter=",0,"current tree sub-iterator.");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fDirection=",0,"iteration direction");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TreeLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TBranchObject */
static void G__setup_memvarTBranchObject(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__TreeLN_TBranchObject));
   { TBranchObject *p; p=(TBranchObject*)0x1000; if (p) { }
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TreeLN_TBranchObjectcLcLdA),-1,-2,2,"kWarn=4096LL",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TreeLN_TString),-1,-1,2,"fClassName=",0,"Class name of referenced object");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TreeLN_TObject),-1,-1,2,"fOldObject=",0,"!Pointer to old object");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TreeLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TIndArray */
static void G__setup_memvarTIndArray(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__TreeLN_TIndArray));
   { TIndArray *p; p=(TIndArray*)0x1000; if (p) { }
   G__memvar_setup((void*)0,108,0,0,-1,-1,-1,4,"G__virtualinfo=",0,(char*)NULL);
   G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,4,"fElems=",0,"Number of elements stored in the array");
   G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,4,"fCapacity=",0,"!Capacity of the array");
   G__memvar_setup((void*)0,66,0,0,-1,G__defined_typename("UChar_t"),-1,4,"fArr=",0,"[fElems] The array");
   }
   G__tag_memvar_reset();
}


   /* TBranchSTL */
static void G__setup_memvarTBranchSTL(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__TreeLN_TBranchSTL));
   { TBranchSTL *p; p=(TBranchSTL*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TreeLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TreeLN_TVirtualCollectionProxy),-1,-1,4,"fCollProxy=",0,"! Collection proxy");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TreeLN_TBranch),-1,-1,4,"fParent=",0,"! Parent of this branch");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TreeLN_TClass),-1,-1,4,"fIndArrayCl=",0,"! Class of the ind array");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TreeLN_TIndArray),-1,-1,4,"fInd=",0,"! Indices");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TreeLN_TString),-1,-1,4,"fContName=",0,"Class name of referenced object");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TreeLN_TString),-1,-1,4,"fClassName=",0,"Name of the parent class, if we're the data member");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fClassVersion=",0,"Version number of the class");
   G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,4,"fClCheckSum=",0,"Class checksum");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TreeLN_TStreamerInfo),-1,-1,4,"fInfo=",0,"! The streamer info");
   G__memvar_setup((void*)0,67,0,0,-1,-1,-1,4,"fObject=",0,"! Pointer to object at address or the");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fID=",0,"Element serial number in the streamer info");
   }
   G__tag_memvar_reset();
}


   /* TChainElement */
static void G__setup_memvarTChainElement(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__TreeLN_TChainElement));
   { TChainElement *p; p=(TChainElement*)0x1000; if (p) { }
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TreeLN_TChainElementcLcLEStatusBits),-1,-2,4,"kHasBeenLookedUp=32768LL",0,(char*)NULL);
   G__memvar_setup((void*)0,110,0,0,-1,G__defined_typename("Long64_t"),-1,2,"fEntries=",0,"Number of entries in the tree of this chain element");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fNPackets=",0,"Number of packets");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fPacketSize=",0,"Number of events in one packet for parallel root");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fStatus=",0,"branch status when used as a branch");
   G__memvar_setup((void*)0,89,0,0,-1,-1,-1,2,"fBaddress=",0,"!branch address when used as a branch");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TreeLN_TString),-1,-1,2,"fBaddressClassName=",0,"!Name of the class pointed to by fBaddress");
   G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,2,"fBaddressType=",0,"!Type of the value pointed to by fBaddress");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fBaddressIsPtr=",0,"!True if the address is a pointer to an address");
   G__memvar_setup((void*)0,67,0,0,-1,-1,-1,2,"fPackets=",0,"!Packet descriptor string");
   G__memvar_setup((void*)0,85,2,0,G__get_linked_tagnum(&G__G__TreeLN_TBranch),-1,-1,2,"fBranchPtr=",0,"!Address of user branch pointer (to updated upon loading a file)");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TreeLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TChain */
static void G__setup_memvarTChain(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__TreeLN_TChain));
   { TChain *p; p=(TChain*)0x1000; if (p) { }
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fTreeOffsetLen=",0,"Current size of fTreeOffset array");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fNtrees=",0,"Number of trees");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fTreeNumber=",0,"! Current Tree number in fTreeOffset table");
   G__memvar_setup((void*)0,78,0,0,-1,G__defined_typename("Long64_t"),-1,2,"fTreeOffset=",0,"[fTreeOffsetLen] Array of variables");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fCanDeleteRefs=",0,"! If true, TProcessIDs are deleted when closing a file");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TreeLN_TTree),-1,-1,2,"fTree=",0,"! Pointer to current tree (Note: We do *not* own this tree.)");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TreeLN_TFile),-1,-1,2,"fFile=",0,"! Pointer to current file (We own the file).");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TreeLN_TObjArray),-1,-1,2,"fFiles=",0,"-> List of file names containing the trees (TChainElement, owned)");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TreeLN_TList),-1,-1,2,"fStatus=",0,"-> List of active/inactive branches (TChainElement, owned)");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TreeLN_TChain),-1,-1,2,"fProofChain=",0,"! chain proxy when going to be processed by PROOF");
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TreeLN_TChaincLcLdA),-1,-2,1,G__FastAllocString(2048).Format("kGlobalWeight=%lldLL",(long long)TChain::kGlobalWeight).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TreeLN_TChaincLcLdA),-1,-2,1,G__FastAllocString(2048).Format("kAutoDelete=%lldLL",(long long)TChain::kAutoDelete).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TreeLN_TChaincLcLdA),-1,-2,1,G__FastAllocString(2048).Format("kProofUptodate=%lldLL",(long long)TChain::kProofUptodate).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TreeLN_TChaincLcLdA),-1,-2,1,G__FastAllocString(2048).Format("kProofLite=%lldLL",(long long)TChain::kProofLite).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TreeLN_TChaincLcLdA),-1,-2,1,G__FastAllocString(2048).Format("kBigNumber=%lldLL",(long long)TChain::kBigNumber).data(),0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TreeLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TEntryListBlock */
static void G__setup_memvarTEntryListBlock(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__TreeLN_TEntryListBlock));
   { TEntryListBlock *p; p=(TEntryListBlock*)0x1000; if (p) { }
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fNPassed=",0,"number of entries in the entry list (if fPassing=0 - number of entries");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fN=",0,"size of fIndices for I/O  =fNPassed for list, fBlockSize for bits");
   G__memvar_setup((void*)0,82,0,0,-1,G__defined_typename("UShort_t"),-1,2,"fIndices=",0,"[fN]");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fType=",0,"0 - bits, 1 - list");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fPassing=",0,"1 - stores entries that belong to the list");
   G__memvar_setup((void*)0,114,0,0,-1,G__defined_typename("UShort_t"),-1,2,"fCurrent=",0,"! to fasten  Contains() in list mode");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fLastIndexQueried=",0,"! to optimize GetEntry() in a loop");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fLastIndexReturned=",0,"! to optimize GetEntry() in a loop");
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TreeLN_TEntryListBlockcLcLdA),-1,-2,1,G__FastAllocString(2048).Format("kBlockSize=%lldLL",(long long)TEntryListBlock::kBlockSize).data(),0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TreeLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TEntryListFromFile */
static void G__setup_memvarTEntryListFromFile(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__TreeLN_TEntryListFromFile));
   { TEntryListFromFile *p; p=(TEntryListFromFile*)0x1000; if (p) { }
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TreeLN_TString),-1,-1,2,"fListFileName=",0,"from this string names of all files can be found");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TreeLN_TString),-1,-1,2,"fListName=",0,"name of the list");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fNFiles=",0,"total number of files");
   G__memvar_setup((void*)0,78,0,0,-1,G__defined_typename("Long64_t"),-1,2,"fListOffset=",0,"[fNFiles] numbers of entries in ind. lists");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TreeLN_TFile),-1,-1,2,"fFile=",0,"currently open file");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TreeLN_TObjArray),-1,-1,2,"fFileNames=",0,"! points to the fFiles data member of the corresponding chain");
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TreeLN_TEntryListFromFilecLcLdA),-1,-2,1,G__FastAllocString(2048).Format("kBigNumber=%lldLL",(long long)TEntryListFromFile::kBigNumber).data(),0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TreeLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TLeafB */
static void G__setup_memvarTLeafB(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__TreeLN_TLeafB));
   { TLeafB *p; p=(TLeafB*)0x1000; if (p) { }
   G__memvar_setup((void*)0,99,0,0,-1,G__defined_typename("Char_t"),-1,2,"fMinimum=",0,"Minimum value if leaf range is specified");
   G__memvar_setup((void*)0,99,0,0,-1,G__defined_typename("Char_t"),-1,2,"fMaximum=",0,"Maximum value if leaf range is specified");
   G__memvar_setup((void*)0,67,0,0,-1,G__defined_typename("Char_t"),-1,2,"fValue=",0,"!Pointer to data buffer");
   G__memvar_setup((void*)0,67,2,0,-1,G__defined_typename("Char_t"),-1,2,"fPointer=",0,"!Address of a pointer to data buffer!");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TreeLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TLeafC */
static void G__setup_memvarTLeafC(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__TreeLN_TLeafC));
   { TLeafC *p; p=(TLeafC*)0x1000; if (p) { }
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fMinimum=",0,"Minimum value if leaf range is specified");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fMaximum=",0,"Maximum value if leaf range is specified");
   G__memvar_setup((void*)0,67,0,0,-1,G__defined_typename("Char_t"),-1,2,"fValue=",0,"!Pointer to data buffer");
   G__memvar_setup((void*)0,67,2,0,-1,G__defined_typename("Char_t"),-1,2,"fPointer=",0,"!Address of pointer to data buffer");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TreeLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TLeafD */
static void G__setup_memvarTLeafD(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__TreeLN_TLeafD));
   { TLeafD *p; p=(TLeafD*)0x1000; if (p) { }
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fMinimum=",0,"Minimum value if leaf range is specified");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fMaximum=",0,"Maximum value if leaf range is specified");
   G__memvar_setup((void*)0,68,0,0,-1,G__defined_typename("Double_t"),-1,2,"fValue=",0,"!Pointer to data buffer");
   G__memvar_setup((void*)0,68,2,0,-1,G__defined_typename("Double_t"),-1,2,"fPointer=",0,"!Address of pointer to data buffer");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TreeLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TLeafElement */
static void G__setup_memvarTLeafElement(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__TreeLN_TLeafElement));
   { TLeafElement *p; p=(TLeafElement*)0x1000; if (p) { }
   G__memvar_setup((void*)0,67,0,0,-1,-1,-1,2,"fAbsAddress=",0,"! Absolute leaf Address");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fID=",0,"element serial number in fInfo");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fType=",0,"leaf type");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TreeLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TLeafF */
static void G__setup_memvarTLeafF(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__TreeLN_TLeafF));
   { TLeafF *p; p=(TLeafF*)0x1000; if (p) { }
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,2,"fMinimum=",0,"Minimum value if leaf range is specified");
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,2,"fMaximum=",0,"Maximum value if leaf range is specified");
   G__memvar_setup((void*)0,70,0,0,-1,G__defined_typename("Float_t"),-1,2,"fValue=",0,"!Pointer to data buffer");
   G__memvar_setup((void*)0,70,2,0,-1,G__defined_typename("Float_t"),-1,2,"fPointer=",0,"!Addresss of pointer to data buffer!");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TreeLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TLeafI */
static void G__setup_memvarTLeafI(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__TreeLN_TLeafI));
   { TLeafI *p; p=(TLeafI*)0x1000; if (p) { }
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fMinimum=",0,"Minimum value if leaf range is specified");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fMaximum=",0,"Maximum value if leaf range is specified");
   G__memvar_setup((void*)0,73,0,0,-1,G__defined_typename("Int_t"),-1,2,"fValue=",0,"!Pointer to data buffer");
   G__memvar_setup((void*)0,73,2,0,-1,G__defined_typename("Int_t"),-1,2,"fPointer=",0,"!Address of pointer to data buffer");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TreeLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TLeafL */
static void G__setup_memvarTLeafL(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__TreeLN_TLeafL));
   { TLeafL *p; p=(TLeafL*)0x1000; if (p) { }
   G__memvar_setup((void*)0,110,0,0,-1,G__defined_typename("Long64_t"),-1,2,"fMinimum=",0,"Minimum value if leaf range is specified");
   G__memvar_setup((void*)0,110,0,0,-1,G__defined_typename("Long64_t"),-1,2,"fMaximum=",0,"Maximum value if leaf range is specified");
   G__memvar_setup((void*)0,78,0,0,-1,G__defined_typename("Long64_t"),-1,2,"fValue=",0,"!Pointer to data buffer");
   G__memvar_setup((void*)0,78,2,0,-1,G__defined_typename("Long64_t"),-1,2,"fPointer=",0,"!Address of pointer to data buffer");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TreeLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TLeafObject */
static void G__setup_memvarTLeafObject(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__TreeLN_TLeafObject));
   { TLeafObject *p; p=(TLeafObject*)0x1000; if (p) { }
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TreeLN_TClassRef),-1,-1,2,"fClass=",0,"! pointer to class");
   G__memvar_setup((void*)0,89,2,0,-1,-1,-1,2,"fObjAddress=",0,"! Address of Pointer to object");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fVirtual=",0,"Support for polymorphism, when set classname is written with object.");
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TreeLN_TLeafObjectcLcLdA),-1,-2,1,G__FastAllocString(2048).Format("kWarn=%lldLL",(long long)TLeafObject::kWarn).data(),0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TreeLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TLeafO */
static void G__setup_memvarTLeafO(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__TreeLN_TLeafO));
   { TLeafO *p; p=(TLeafO*)0x1000; if (p) { }
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fMinimum=",0,"Minimum value if leaf range is specified");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fMaximum=",0,"Maximum value if leaf range is specified");
   G__memvar_setup((void*)0,71,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fValue=",0,"!Pointer to data buffer");
   G__memvar_setup((void*)0,71,2,0,-1,G__defined_typename("Bool_t"),-1,2,"fPointer=",0,"!Address of a pointer to data buffer!");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TreeLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TLeafS */
static void G__setup_memvarTLeafS(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__TreeLN_TLeafS));
   { TLeafS *p; p=(TLeafS*)0x1000; if (p) { }
   G__memvar_setup((void*)0,115,0,0,-1,G__defined_typename("Short_t"),-1,2,"fMinimum=",0,"Minimum value if leaf range is specified");
   G__memvar_setup((void*)0,115,0,0,-1,G__defined_typename("Short_t"),-1,2,"fMaximum=",0,"Maximum value if leaf range is specified");
   G__memvar_setup((void*)0,83,0,0,-1,G__defined_typename("Short_t"),-1,2,"fValue=",0,"!Pointer to data buffer");
   G__memvar_setup((void*)0,83,2,0,-1,G__defined_typename("Short_t"),-1,2,"fPointer=",0,"!Address of pointer to data buffer");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TreeLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TNtupleD */
static void G__setup_memvarTNtupleD(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__TreeLN_TNtupleD));
   { TNtupleD *p; p=(TNtupleD*)0x1000; if (p) { }
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fNvar=",0,"Number of columns");
   G__memvar_setup((void*)0,68,0,0,-1,G__defined_typename("Double_t"),-1,2,"fArgs=",0,"! [fNvar] Array of variables");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TreeLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TNtuple */
static void G__setup_memvarTNtuple(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__TreeLN_TNtuple));
   { TNtuple *p; p=(TNtuple*)0x1000; if (p) { }
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fNvar=",0,"Number of columns");
   G__memvar_setup((void*)0,70,0,0,-1,G__defined_typename("Float_t"),-1,2,"fArgs=",0,"! [fNvar] Array of variables");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TreeLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TQueryResult */
static void G__setup_memvarTQueryResult(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__TreeLN_TQueryResult));
   { TQueryResult *p; p=(TQueryResult*)0x1000; if (p) { }
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TreeLN_TQueryResultcLcLEQueryStatus),-1,-2,1,G__FastAllocString(2048).Format("kAborted=%lldLL",(long long)TQueryResult::kAborted).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TreeLN_TQueryResultcLcLEQueryStatus),-1,-2,1,G__FastAllocString(2048).Format("kSubmitted=%lldLL",(long long)TQueryResult::kSubmitted).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TreeLN_TQueryResultcLcLEQueryStatus),-1,-2,1,G__FastAllocString(2048).Format("kRunning=%lldLL",(long long)TQueryResult::kRunning).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TreeLN_TQueryResultcLcLEQueryStatus),-1,-2,1,G__FastAllocString(2048).Format("kStopped=%lldLL",(long long)TQueryResult::kStopped).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TreeLN_TQueryResultcLcLEQueryStatus),-1,-2,1,G__FastAllocString(2048).Format("kCompleted=%lldLL",(long long)TQueryResult::kCompleted).data(),0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fSeqNum=",0,"query unique sequential number");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fDraw=",0,"true if draw action query");
   G__memvar_setup((void*)0,105,0,0,G__get_linked_tagnum(&G__G__TreeLN_TQueryResultcLcLEQueryStatus),-1,-1,2,"fStatus=",0,"query status");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TreeLN_TDatime),-1,-1,2,"fStart=",0,"time when processing started");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TreeLN_TDatime),-1,-1,2,"fEnd=",0,"time when processing ended");
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,2,"fUsedCPU=",0,"real CPU time used (seconds)");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TreeLN_TString),-1,-1,2,"fOptions=",0,"processing options + aclic mode (<opt>#<aclic_mode>)");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TreeLN_TList),-1,-1,2,"fInputList=",0,"input list; contains also data sets, entry list, ...");
   G__memvar_setup((void*)0,110,0,0,-1,G__defined_typename("Long64_t"),-1,2,"fEntries=",0,"number of entries processed");
   G__memvar_setup((void*)0,110,0,0,-1,G__defined_typename("Long64_t"),-1,2,"fFirst=",0,"first entry processed");
   G__memvar_setup((void*)0,110,0,0,-1,G__defined_typename("Long64_t"),-1,2,"fBytes=",0,"number of bytes processed");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TreeLN_TMacro),-1,-1,2,"fLogFile=",0,"file with log messages from the query");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TreeLN_TMacro),-1,-1,2,"fSelecHdr=",0,"selector header file");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TreeLN_TMacro),-1,-1,2,"fSelecImp=",0,"selector implementation file");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TreeLN_TString),-1,-1,2,"fLibList=",0,"blank-separated list of libs loaded at fStart");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TreeLN_TString),-1,-1,2,"fParList=",0,"colon-separated list of PAR loaded at fStart");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TreeLN_TList),-1,-1,2,"fOutputList=",0,"output list");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fFinalized=",0,"whether Terminate has been run");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fArchived=",0,"whether the query has been archived");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TreeLN_TString),-1,-1,2,"fResultFile=",0,"URL of the file where results have been archived");
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,2,"fInitTime=",0,"Initialization time (seconds) (millisec precision)");
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,2,"fProcTime=",0,"Processing time (seconds) (millisec precision)");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fNumWrks=",0,"Number of workers at start");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TreeLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TSelectorList */
static void G__setup_memvarTSelectorList(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__TreeLN_TSelectorList));
   { TSelectorList *p; p=(TSelectorList*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TreeLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TSelectorCint */
static void G__setup_memvarTSelectorCint(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__TreeLN_TSelectorCint));
   { TSelectorCint *p; p=(TSelectorCint*)0x1000; if (p) { }
   G__memvar_setup((void*)0,89,0,0,-1,G__defined_typename("ClassInfo_t"),-1,2,"fClass=",0,"!");
   G__memvar_setup((void*)0,89,0,0,-1,G__defined_typename("CallFunc_t"),-1,2,"fFuncVersion=",0,"!");
   G__memvar_setup((void*)0,89,0,0,-1,G__defined_typename("CallFunc_t"),-1,2,"fFuncInit=",0,"!");
   G__memvar_setup((void*)0,89,0,0,-1,G__defined_typename("CallFunc_t"),-1,2,"fFuncBegin=",0,"!");
   G__memvar_setup((void*)0,89,0,0,-1,G__defined_typename("CallFunc_t"),-1,2,"fFuncSlBegin=",0,"!");
   G__memvar_setup((void*)0,89,0,0,-1,G__defined_typename("CallFunc_t"),-1,2,"fFuncNotif=",0,"!");
   G__memvar_setup((void*)0,89,0,0,-1,G__defined_typename("CallFunc_t"),-1,2,"fFuncSlTerm=",0,"!");
   G__memvar_setup((void*)0,89,0,0,-1,G__defined_typename("CallFunc_t"),-1,2,"fFuncTerm=",0,"!");
   G__memvar_setup((void*)0,89,0,0,-1,G__defined_typename("CallFunc_t"),-1,2,"fFuncCut=",0,"!");
   G__memvar_setup((void*)0,89,0,0,-1,G__defined_typename("CallFunc_t"),-1,2,"fFuncFill=",0,"!");
   G__memvar_setup((void*)0,89,0,0,-1,G__defined_typename("CallFunc_t"),-1,2,"fFuncProc=",0,"!");
   G__memvar_setup((void*)0,89,0,0,-1,G__defined_typename("CallFunc_t"),-1,2,"fFuncOption=",0,"!");
   G__memvar_setup((void*)0,89,0,0,-1,G__defined_typename("CallFunc_t"),-1,2,"fFuncObj=",0,"!");
   G__memvar_setup((void*)0,89,0,0,-1,G__defined_typename("CallFunc_t"),-1,2,"fFuncInp=",0,"!");
   G__memvar_setup((void*)0,89,0,0,-1,G__defined_typename("CallFunc_t"),-1,2,"fFuncOut=",0,"!");
   G__memvar_setup((void*)0,89,0,0,-1,G__defined_typename("CallFunc_t"),-1,2,"fFuncGetAbort=",0,"!");
   G__memvar_setup((void*)0,89,0,0,-1,G__defined_typename("CallFunc_t"),-1,2,"fFuncGetStat=",0,"!");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TreeLN_TSelector),-1,-1,2,"fIntSelector=",0,"Pointer to interpreted selector (if interpreted)");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fIsOwner=",0,"True if fIntSelector shoudl be deleted when the this object is deleted.");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TreeLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TSelectorScalar */
static void G__setup_memvarTSelectorScalar(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__TreeLN_TSelectorScalar));
   { TSelectorScalar *p; p=(TSelectorScalar*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TreeLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TTreeCache */
static void G__setup_memvarTTreeCache(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__TreeLN_TTreeCache));
   { TTreeCache *p; p=(TTreeCache*)0x1000; if (p) { }
   G__memvar_setup((void*)0,110,0,0,-1,G__defined_typename("Long64_t"),-1,2,"fEntryMin=",0,"! first entry in the cache");
   G__memvar_setup((void*)0,110,0,0,-1,G__defined_typename("Long64_t"),-1,2,"fEntryMax=",0,"! last entry in the cache");
   G__memvar_setup((void*)0,110,0,0,-1,G__defined_typename("Long64_t"),-1,2,"fEntryCurrent=",0,"! current lowest entry number in the cache");
   G__memvar_setup((void*)0,110,0,0,-1,G__defined_typename("Long64_t"),-1,2,"fEntryNext=",0,"! next entry number where cache must be filled");
   G__memvar_setup((void*)0,110,0,0,-1,G__defined_typename("Long64_t"),-1,2,"fZipBytes=",0,"! Total compressed size of branches in cache");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fNbranches=",0,"! Number of branches in the cache");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fNReadOk=",0,"Number of blocks read and found in the cache");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fNReadMiss=",0,"Number of blocks read and not found in the chache");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fNReadPref=",0,"Number of blocks that were prefetched");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TreeLN_TObjArray),-1,-1,2,"fBranches=",0,"! List of branches to be stored in the cache");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TreeLN_TList),-1,-1,2,"fBrNames=",0,"! list of branch names in the cache");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TreeLN_TTree),-1,-1,2,"fOwner=",0,"! pointer to the owner Tree/chain");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TreeLN_TTree),-1,-1,2,"fTree=",0,"! pointer to the current Tree");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fIsLearning=",0,"! true if cache is in learning mode");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fIsManual=",0,"! true if cache is StopLearningPhase was used");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-2,2,"fgLearnEntries=",0,"Number of entries used for learning mode");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TreeLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TTreeCacheUnzip */
static void G__setup_memvarTTreeCacheUnzip(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__TreeLN_TTreeCacheUnzip));
   { TTreeCacheUnzip *p; p=(TTreeCacheUnzip*)0x1000; if (p) { }
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TreeLN_TTreeCacheUnzipcLcLEParUnzipMode),-1,-2,1,G__FastAllocString(2048).Format("kEnable=%lldLL",(long long)TTreeCacheUnzip::kEnable).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TreeLN_TTreeCacheUnzipcLcLEParUnzipMode),-1,-2,1,G__FastAllocString(2048).Format("kDisable=%lldLL",(long long)TTreeCacheUnzip::kDisable).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TreeLN_TTreeCacheUnzipcLcLEParUnzipMode),-1,-2,1,G__FastAllocString(2048).Format("kForce=%lldLL",(long long)TTreeCacheUnzip::kForce).data(),0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TreeLN_TThread),-1,-1,2,"fUnzipThread[10]=",0,(char*)NULL);
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fActiveThread=",0,"Used to terminate gracefully the unzippers");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TreeLN_TCondition),-1,-1,2,"fUnzipStartCondition=",0,"Used to signal the threads to start.");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TreeLN_TCondition),-1,-1,2,"fUnzipDoneCondition=",0,"Used to wait for an unzip tour to finish. Gives the Async feel.");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fParallel=",0,"Indicate if we want to activate the parallelism (for this instance)");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fAsyncReading=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TreeLN_TMutex),-1,-1,2,"fMutexList=",0,"Mutex to protect the various lists. Used by the condvars.");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TreeLN_TMutex),-1,-1,2,"fIOMutex=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fCycle=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,G__get_linked_tagnum(&G__G__TreeLN_TTreeCacheUnzipcLcLEParUnzipMode),-1,-2,2,"fgParallel=",0,"Indicate if we want to activate the parallelism");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fLastReadPos=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fBlocksToGo=",0,(char*)NULL);
   G__memvar_setup((void*)0,73,0,0,-1,G__defined_typename("Int_t"),-1,2,"fUnzipLen=",0,"! [fNseek] Length of the unzipped buffers");
   G__memvar_setup((void*)0,67,2,0,-1,-1,-1,2,"fUnzipChunks=",0,"! [fNseek] Individual unzipped chunks. Their summed size is kept under control.");
   G__memvar_setup((void*)0,66,0,0,-1,G__defined_typename("Byte_t"),-1,2,"fUnzipStatus=",0,"! [fNSeek] For each blk, tells us if it's unzipped or pending");
   G__memvar_setup((void*)0,110,0,0,-1,G__defined_typename("Long64_t"),-1,2,"fTotalUnzipBytes=",0,"! The total sum of the currently unzipped blks");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fNseekMax=",0,"!  fNseek can change so we need to know its max size");
   G__memvar_setup((void*)0,110,0,0,-1,G__defined_typename("Long64_t"),-1,2,"fUnzipBufferSize=",0,"!  Max Size for the ready unzipped blocks (default is 2*fBufferSize)");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-2,2,"fgRelBuffSize=",0,"This is the percentage of the TTreeCacheUnzip that will be used");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fNUnzip=",0,"! number of blocks that were unzipped");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fNFound=",0,"! number of blocks that were found in the cache");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fNStalls=",0,"! number of hits which caused a stall");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fNMissed=",0,"! number of blocks that were not found in the cache and were unzipped");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TreeLN_queuelEintcOdequelEintcOallocatorlEintgRsPgRsPgR),G__defined_typename("queue<Int_t>"),-1,2,"fActiveBlks=",0,"The blocks which are active now");
   G__memvar_setup((void*)0,67,0,0,-1,-1,-1,4,"fCompBuffer=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fCompBufferSize=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TreeLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TTreeResult */
static void G__setup_memvarTTreeResult(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__TreeLN_TTreeResult));
   { TTreeResult *p; p=(TTreeResult*)0x1000; if (p) { }
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fColumnCount=",0,"number of columns in result");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TreeLN_TString),-1,-1,4,"fFields=",0,"[fColumnCount] array containing field strings");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TreeLN_TObjArray),-1,-1,4,"fResult=",0,"query result (TTreeRow objects)");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fNextRow=",0,"row iterator");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TreeLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TTreeRow */
static void G__setup_memvarTTreeRow(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__TreeLN_TTreeRow));
   { TTreeRow *p; p=(TTreeRow*)0x1000; if (p) { }
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fColumnCount=",0,"number of columns in row");
   G__memvar_setup((void*)0,73,0,0,-1,G__defined_typename("Int_t"),-1,4,"fFields=",0,"[fColumnCount] index in fRow of the end of each field");
   G__memvar_setup((void*)0,67,0,0,-1,-1,-1,4,"fRow=",0,"string with all the fColumnCount fields");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TreeLN_TTreeRow),-1,-1,4,"fOriginal=",0,"! pointer to original row");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TreeLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TTreeSQL */
static void G__setup_memvarTTreeSQL(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__TreeLN_TTreeSQL));
   { TTreeSQL *p; p=(TTreeSQL*)0x1000; if (p) { }
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fCurrentEntry=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TreeLN_TString),-1,-1,2,"fDB=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TreeLN_TString),-1,-1,2,"fInsertQuery=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TreeLN_TString),-1,-1,2,"fQuery=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TreeLN_TString),-1,-1,2,"fTable=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TreeLN_TSQLResult),-1,-1,2,"fResult=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TreeLN_TSQLRow),-1,-1,2,"fRow=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TreeLN_TSQLServer),-1,-1,2,"fServer=",0,(char*)NULL);
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fBranchChecked=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TreeLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}

extern "C" void G__cpp_setup_memvarG__Tree() {
}
/***********************************************************
************************************************************
************************************************************
************************************************************
************************************************************
************************************************************
************************************************************
***********************************************************/

/*********************************************************
* Member function information setup for each class
*********************************************************/
static void G__setup_memfuncTTree(void) {
   /* TTree */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__TreeLN_TTree));
   G__memfunc_setup("TTree",484,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__TreeLN_TTree), -1, 0, 1, 1, 4, 0, "u 'TTree' - 11 - tt", "not implemented", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__TreeLN_TTree), -1, 1, 1, 1, 4, 0, "u 'TTree' - 11 - tt", "not implemented", (void*) NULL, 0);
   G__memfunc_setup("AddClone",762,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 0, "U 'TTree' - 0 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("KeepCircular",1210,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("BranchImp",884,(G__InterfaceMethod) NULL, 85, G__get_linked_tagnum(&G__G__TreeLN_TBranch), -1, 0, 6, 1, 2, 0, 
"C - - 10 - branchname C - - 10 - classname "
"U 'TClass' - 0 - ptrClass Y - - 0 - addobj "
"i - 'Int_t' 0 - bufsize i - 'Int_t' 0 - splitlevel", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("BranchImp",884,(G__InterfaceMethod) NULL, 85, G__get_linked_tagnum(&G__G__TreeLN_TBranch), -1, 0, 5, 1, 2, 0, 
"C - - 10 - branchname U 'TClass' - 0 - ptrClass "
"Y - - 0 - addobj i - 'Int_t' 0 - bufsize "
"i - 'Int_t' 0 - splitlevel", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("BranchImpRef",1169,(G__InterfaceMethod) NULL, 85, G__get_linked_tagnum(&G__G__TreeLN_TBranch), -1, 0, 6, 1, 2, 0, 
"C - - 10 - branchname C - - 10 - classname "
"U 'TClass' - 0 - ptrClass Y - - 0 - addobj "
"i - 'Int_t' 0 - bufsize i - 'Int_t' 0 - splitlevel", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("BranchImpRef",1169,(G__InterfaceMethod) NULL, 85, G__get_linked_tagnum(&G__G__TreeLN_TBranch), -1, 0, 6, 1, 2, 0, 
"C - - 10 - branchname U 'TClass' - 0 - ptrClass "
"i 'EDataType' - 0 - datatype Y - - 0 - addobj "
"i - 'Int_t' 0 - bufsize i - 'Int_t' 0 - splitlevel", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("CheckBranchAddressType",2196,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 4, 1, 2, 0, 
"U 'TBranch' - 0 - branch U 'TClass' - 0 - ptrClass "
"i 'EDataType' - 0 - datatype g - 'Bool_t' 0 - ptr", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("BronchExec",993,(G__InterfaceMethod) NULL, 85, G__get_linked_tagnum(&G__G__TreeLN_TBranch), -1, 0, 6, 1, 2, 0, 
"C - - 10 - name C - - 10 - classname "
"Y - - 0 - addobj g - 'Bool_t' 0 - isptrptr "
"i - 'Int_t' 0 - bufsize i - 'Int_t' 0 - splitlevel", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetBranchAddressImp",1894,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 3, 1, 2, 0, 
"U 'TBranch' - 0 - branch Y - - 0 - addr "
"U 'TBranch' - 2 - ptr", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TTree",484,G__G__Tree_113_0_12, 105, G__get_linked_tagnum(&G__G__TreeLN_TTree), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TTree",484,G__G__Tree_113_0_13, 105, G__get_linked_tagnum(&G__G__TreeLN_TTree), -1, 0, 3, 1, 1, 0, 
"C - - 10 - name C - - 10 - title "
"i - 'Int_t' 0 '99' splitlevel", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddBranchToCache",1518,G__G__Tree_113_0_14, 121, -1, -1, 0, 2, 1, 1, 0, 
"C - - 10 - bname g - 'Bool_t' 0 'kFALSE' subbranches", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("AddBranchToCache",1518,G__G__Tree_113_0_15, 121, -1, -1, 0, 2, 1, 1, 0, 
"U 'TBranch' - 0 - branch g - 'Bool_t' 0 'kFALSE' subbranches", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("AddFriend",865,G__G__Tree_113_0_16, 85, G__get_linked_tagnum(&G__G__TreeLN_TFriendElement), -1, 0, 2, 1, 1, 0, 
"C - - 10 - treename C - - 10 '\"\"' filename", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("AddFriend",865,G__G__Tree_113_0_17, 85, G__get_linked_tagnum(&G__G__TreeLN_TFriendElement), -1, 0, 2, 1, 1, 0, 
"C - - 10 - treename U 'TFile' - 0 - file", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("AddFriend",865,G__G__Tree_113_0_18, 85, G__get_linked_tagnum(&G__G__TreeLN_TFriendElement), -1, 0, 3, 1, 1, 0, 
"U 'TTree' - 0 - tree C - - 10 '\"\"' alias "
"g - 'Bool_t' 0 'kFALSE' warn", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("AddTotBytes",1095,G__G__Tree_113_0_19, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - tot", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("AddZipBytes",1091,G__G__Tree_113_0_20, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - zip", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("AutoSave",808,G__G__Tree_113_0_21, 110, -1, G__defined_typename("Long64_t"), 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Branch",590,G__G__Tree_113_0_22, 105, -1, G__defined_typename("Int_t"), 0, 4, 1, 1, 0, 
"U 'TCollection' - 0 - list i - 'Int_t' 0 '32000' bufsize "
"i - 'Int_t' 0 '99' splitlevel C - - 10 '\"\"' name", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Branch",590,G__G__Tree_113_0_23, 105, -1, G__defined_typename("Int_t"), 0, 3, 1, 1, 0, 
"U 'TList' - 0 - list i - 'Int_t' 0 '32000' bufsize "
"i - 'Int_t' 0 '99' splitlevel", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Branch",590,G__G__Tree_113_0_24, 105, -1, G__defined_typename("Int_t"), 0, 3, 1, 1, 0, 
"C - - 10 - folder i - 'Int_t' 0 '32000' bufsize "
"i - 'Int_t' 0 '99' splitlevel", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Branch",590,G__G__Tree_113_0_25, 85, G__get_linked_tagnum(&G__G__TreeLN_TBranch), -1, 0, 4, 1, 1, 0, 
"C - - 10 - name Y - - 0 - address "
"C - - 10 - leaflist i - 'Int_t' 0 '32000' bufsize", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Branch",590,G__G__Tree_113_0_26, 85, G__get_linked_tagnum(&G__G__TreeLN_TBranch), -1, 0, 4, 1, 1, 0, 
"C - - 10 - name C - - 0 - address "
"C - - 10 - leaflist i - 'Int_t' 0 '32000' bufsize", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Branch",590,G__G__Tree_113_0_27, 85, G__get_linked_tagnum(&G__G__TreeLN_TBranch), -1, 0, 4, 1, 1, 0, 
"C - - 10 - name l - - 0 - address "
"C - - 10 - leaflist i - 'Int_t' 0 '32000' bufsize", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Branch",590,G__G__Tree_113_0_28, 85, G__get_linked_tagnum(&G__G__TreeLN_TBranch), -1, 0, 4, 1, 1, 0, 
"C - - 10 - name i - - 0 - address "
"C - - 10 - leaflist i - 'Int_t' 0 '32000' bufsize", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Bronch",604,G__G__Tree_113_0_29, 85, G__get_linked_tagnum(&G__G__TreeLN_TBranch), -1, 0, 5, 1, 1, 0, 
"C - - 10 - name C - - 10 - classname "
"Y - - 0 - addobj i - 'Int_t' 0 '32000' bufsize "
"i - 'Int_t' 0 '99' splitlevel", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("BranchOld",877,G__G__Tree_113_0_30, 85, G__get_linked_tagnum(&G__G__TreeLN_TBranch), -1, 0, 5, 1, 1, 0, 
"C - - 10 - name C - - 10 - classname "
"Y - - 0 - addobj i - 'Int_t' 0 '32000' bufsize "
"i - 'Int_t' 0 '1' splitlevel", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("BranchRef",875,G__G__Tree_113_0_31, 85, G__get_linked_tagnum(&G__G__TreeLN_TBranch), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Browse",626,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TBrowser' - 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("BuildIndex",1000,G__G__Tree_113_0_33, 105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 0, 
"C - - 10 - majorname C - - 10 '\"0\"' minorname", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("BuildStreamerInfo",1727,G__G__Tree_113_0_34, 85, G__get_linked_tagnum(&G__G__TreeLN_TStreamerInfo), -1, 0, 3, 1, 1, 0, 
"U 'TClass' - 0 - cl Y - - 0 '0' pointer "
"g - 'Bool_t' 0 'kTRUE' canOptimize", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ChangeFile",966,G__G__Tree_113_0_35, 85, G__get_linked_tagnum(&G__G__TreeLN_TFile), -1, 0, 1, 1, 1, 0, "U 'TFile' - 0 - file", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("CloneTree",897,G__G__Tree_113_0_36, 85, G__get_linked_tagnum(&G__G__TreeLN_TTree), -1, 0, 2, 1, 1, 0, 
"n - 'Long64_t' 0 '-1' nentries C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("CopyAddresses",1337,G__G__Tree_113_0_37, 121, -1, -1, 0, 2, 1, 1, 0, 
"U 'TTree' - 0 - - g - 'Bool_t' 0 'kFALSE' undo", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("CopyEntries",1141,G__G__Tree_113_0_38, 110, -1, G__defined_typename("Long64_t"), 0, 3, 1, 1, 0, 
"U 'TTree' - 0 - tree n - 'Long64_t' 0 '-1' nentries "
"C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("CopyTree",811,G__G__Tree_113_0_39, 85, G__get_linked_tagnum(&G__G__TreeLN_TTree), -1, 0, 4, 1, 1, 0, 
"C - - 10 - selection C - 'Option_t' 10 '\"\"' option "
"n - 'Long64_t' 0 '1000000000' nentries n - 'Long64_t' 0 '0' firstentry", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("CreateBasket",1198,G__G__Tree_113_0_40, 85, G__get_linked_tagnum(&G__G__TreeLN_TBasket), -1, 0, 1, 1, 1, 0, "U 'TBranch' - 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DirectoryAutoAdd",1623,G__G__Tree_113_0_41, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TDirectory' - 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Debug",487,G__G__Tree_113_0_42, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Delete",595,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", "*MENU*", (void*) NULL, 1);
   G__memfunc_setup("Draw",398,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 - opt", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Draw",398,G__G__Tree_113_0_45, 110, -1, G__defined_typename("Long64_t"), 0, 5, 1, 1, 0, 
"C - - 10 - varexp u 'TCut' - 11 - selection "
"C - 'Option_t' 10 '\"\"' option n - 'Long64_t' 0 '1000000000' nentries "
"n - 'Long64_t' 0 '0' firstentry", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Draw",398,G__G__Tree_113_0_46, 110, -1, G__defined_typename("Long64_t"), 0, 5, 1, 1, 0, 
"C - - 10 - varexp C - - 10 - selection "
"C - 'Option_t' 10 '\"\"' option n - 'Long64_t' 0 '1000000000' nentries "
"n - 'Long64_t' 0 '0' firstentry", "*MENU*", (void*) NULL, 1);
   G__memfunc_setup("DropBaskets",1122,G__G__Tree_113_0_47, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DropBuffers",1122,G__G__Tree_113_0_48, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - nbytes", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Fill",391,G__G__Tree_113_0_49, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("FindBranch",975,G__G__Tree_113_0_50, 85, G__get_linked_tagnum(&G__G__TreeLN_TBranch), -1, 0, 1, 1, 1, 0, "C - - 10 - name", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("FindLeaf",761,G__G__Tree_113_0_51, 85, G__get_linked_tagnum(&G__G__TreeLN_TLeaf), -1, 0, 1, 1, 1, 0, "C - - 10 - name", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Fit",291,G__G__Tree_113_0_52, 105, -1, G__defined_typename("Int_t"), 0, 7, 1, 1, 0, 
"C - - 10 - funcname C - - 10 - varexp "
"C - - 10 '\"\"' selection C - 'Option_t' 10 '\"\"' option "
"C - 'Option_t' 10 '\"\"' goption n - 'Long64_t' 0 '1000000000' nentries "
"n - 'Long64_t' 0 '0' firstentry", "*MENU*", (void*) NULL, 1);
   G__memfunc_setup("FlushBaskets",1231,G__G__Tree_113_0_53, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetAlias",778,G__G__Tree_113_0_54, 67, -1, -1, 0, 1, 1, 1, 9, "C - - 10 - aliasName", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetAutoFlush",1211,G__G__Tree_113_0_55, 110, -1, G__defined_typename("Long64_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetAutoSave",1096,G__G__Tree_113_0_56, 110, -1, G__defined_typename("Long64_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetBranch",878,G__G__Tree_113_0_57, 85, G__get_linked_tagnum(&G__G__TreeLN_TBranch), -1, 0, 1, 1, 1, 0, "C - - 10 - name", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetBranchRef",1163,G__G__Tree_113_0_58, 85, G__get_linked_tagnum(&G__G__TreeLN_TBranchRef), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetBranchStatus",1522,G__G__Tree_113_0_59, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 8, "C - - 10 - branchname", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetBranchStyle",1407,G__G__Tree_113_0_60, 105, -1, G__defined_typename("Int_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Int_t (*)())(&TTree::GetBranchStyle) ), 0);
   G__memfunc_setup("GetCacheSize",1167,G__G__Tree_113_0_61, 110, -1, G__defined_typename("Long64_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetChainEntryNumber",1918,G__G__Tree_113_0_62, 110, -1, G__defined_typename("Long64_t"), 0, 1, 1, 1, 8, "n - 'Long64_t' 0 - entry", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetChainOffset",1386,G__G__Tree_113_0_63, 110, -1, G__defined_typename("Long64_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetCurrentFile",1411,G__G__Tree_113_0_64, 85, G__get_linked_tagnum(&G__G__TreeLN_TFile), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetDefaultEntryOffsetLen",2429,G__G__Tree_113_0_65, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetDebugMax",1069,G__G__Tree_113_0_66, 110, -1, G__defined_typename("Long64_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetDebugMin",1067,G__G__Tree_113_0_67, 110, -1, G__defined_typename("Long64_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetDirectory",1237,G__G__Tree_113_0_68, 85, G__get_linked_tagnum(&G__G__TreeLN_TDirectory), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetEntries",1018,G__G__Tree_113_0_69, 110, -1, G__defined_typename("Long64_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetEntries",1018,G__G__Tree_113_0_70, 110, -1, G__defined_typename("Long64_t"), 0, 1, 1, 1, 0, "C - - 10 - selection", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetEntriesFast",1416,G__G__Tree_113_0_71, 110, -1, G__defined_typename("Long64_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetEntriesFriend",1618,G__G__Tree_113_0_72, 110, -1, G__defined_typename("Long64_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetEstimate",1116,G__G__Tree_113_0_73, 110, -1, G__defined_typename("Long64_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetEntry",818,G__G__Tree_113_0_74, 105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 0, 
"n - 'Long64_t' 0 '0' entry i - 'Int_t' 0 '0' getall", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetEvent",802,G__G__Tree_113_0_75, 105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 0, 
"n - 'Long64_t' 0 '0' entry i - 'Int_t' 0 '0' getall", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetEntryWithIndex",1734,G__G__Tree_113_0_76, 105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - major i - 'Int_t' 0 '0' minor", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetEntryNumberWithBestIndex",2749,G__G__Tree_113_0_77, 110, -1, G__defined_typename("Long64_t"), 0, 2, 1, 1, 8, 
"i - 'Int_t' 0 - major i - 'Int_t' 0 '0' minor", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetEntryNumberWithIndex",2351,G__G__Tree_113_0_78, 110, -1, G__defined_typename("Long64_t"), 0, 2, 1, 1, 8, 
"i - 'Int_t' 0 - major i - 'Int_t' 0 '0' minor", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetEventList",1214,G__G__Tree_113_0_79, 85, G__get_linked_tagnum(&G__G__TreeLN_TEventList), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetEntryList",1230,G__G__Tree_113_0_80, 85, G__get_linked_tagnum(&G__G__TreeLN_TEntryList), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetEntryNumber",1435,G__G__Tree_113_0_81, 110, -1, G__defined_typename("Long64_t"), 0, 1, 1, 1, 8, "n - 'Long64_t' 0 - entry", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetFileNumber",1289,G__G__Tree_113_0_82, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetFriend",888,G__G__Tree_113_0_83, 85, G__get_linked_tagnum(&G__G__TreeLN_TTree), -1, 0, 1, 1, 1, 8, "C - - 10 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetFriendAlias",1378,G__G__Tree_113_0_84, 67, -1, -1, 0, 1, 1, 1, 9, "U 'TTree' - 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetHistogram",1230,G__G__Tree_113_0_85, 85, G__get_linked_tagnum(&G__G__TreeLN_TH1), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetIndex",792,G__G__Tree_113_0_86, 73, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetIndexValues",1416,G__G__Tree_113_0_87, 68, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetIteratorOnAllLeaves",2208,G__G__Tree_113_0_88, 85, G__get_linked_tagnum(&G__G__TreeLN_TIterator), -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kIterForward' dir", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetLeaf",664,G__G__Tree_113_0_89, 85, G__get_linked_tagnum(&G__G__TreeLN_TLeaf), -1, 0, 1, 1, 1, 0, "C - - 10 - name", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetListOfClones",1493,G__G__Tree_113_0_90, 85, G__get_linked_tagnum(&G__G__TreeLN_TList), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetListOfBranches",1687,G__G__Tree_113_0_91, 85, G__get_linked_tagnum(&G__G__TreeLN_TObjArray), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetListOfLeaves",1489,G__G__Tree_113_0_92, 85, G__get_linked_tagnum(&G__G__TreeLN_TObjArray), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetListOfFriends",1596,G__G__Tree_113_0_93, 85, G__get_linked_tagnum(&G__G__TreeLN_TList), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetListOfAliases",1587,G__G__Tree_113_0_94, 85, G__get_linked_tagnum(&G__G__TreeLN_TList), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetMakeClass",1172,G__G__Tree_113_0_95, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMaxEntryLoop",1522,G__G__Tree_113_0_96, 110, -1, G__defined_typename("Long64_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetMaximum",1022,G__G__Tree_113_0_97, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 0, "C - - 10 - columname", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetMaxTreeSize",1393,G__G__Tree_113_0_98, 110, -1, G__defined_typename("Long64_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Long64_t (*)())(&TTree::GetMaxTreeSize) ), 0);
   G__memfunc_setup("GetMaxVirtualSize",1736,G__G__Tree_113_0_99, 110, -1, G__defined_typename("Long64_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetMinimum",1020,G__G__Tree_113_0_100, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 0, "C - - 10 - columname", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetNbranches",1204,G__G__Tree_113_0_101, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetNotify",921,G__G__Tree_113_0_102, 85, G__get_linked_tagnum(&G__G__TreeLN_TObject), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetPlayer",909,G__G__Tree_113_0_103, 85, G__get_linked_tagnum(&G__G__TreeLN_TVirtualTreePlayer), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetPacketSize",1299,G__G__Tree_113_0_104, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetReadEntry",1198,G__G__Tree_113_0_105, 110, -1, G__defined_typename("Long64_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetReadEvent",1182,G__G__Tree_113_0_106, 110, -1, G__defined_typename("Long64_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetScanField",1161,G__G__Tree_113_0_107, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetSelect",896,G__G__Tree_113_0_108, 85, G__get_linked_tagnum(&G__G__TreeLN_TTreeFormula), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetSelectedRows",1524,G__G__Tree_113_0_109, 110, -1, G__defined_typename("Long64_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetTimerInterval",1638,G__G__Tree_113_0_110, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetTotBytes",1118,G__G__Tree_113_0_111, 110, -1, G__defined_typename("Long64_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetTree",688,G__G__Tree_113_0_112, 85, G__get_linked_tagnum(&G__G__TreeLN_TTree), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetTreeIndex",1192,G__G__Tree_113_0_113, 85, G__get_linked_tagnum(&G__G__TreeLN_TVirtualIndex), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetTreeNumber",1305,G__G__Tree_113_0_114, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetUpdate",899,G__G__Tree_113_0_115, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetUserInfo",1099,G__G__Tree_113_0_116, 85, G__get_linked_tagnum(&G__G__TreeLN_TList), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetVar",585,G__G__Tree_113_0_117, 85, G__get_linked_tagnum(&G__G__TreeLN_TTreeFormula), -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetVar1",634,G__G__Tree_113_0_118, 85, G__get_linked_tagnum(&G__G__TreeLN_TTreeFormula), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetVar2",635,G__G__Tree_113_0_119, 85, G__get_linked_tagnum(&G__G__TreeLN_TTreeFormula), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetVar3",636,G__G__Tree_113_0_120, 85, G__get_linked_tagnum(&G__G__TreeLN_TTreeFormula), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetVar4",637,G__G__Tree_113_0_121, 85, G__get_linked_tagnum(&G__G__TreeLN_TTreeFormula), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetVal",579,G__G__Tree_113_0_122, 68, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 0, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetV1",423,G__G__Tree_113_0_123, 68, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetV2",424,G__G__Tree_113_0_124, 68, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetV3",425,G__G__Tree_113_0_125, 68, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetV4",426,G__G__Tree_113_0_126, 68, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetW",375,G__G__Tree_113_0_127, 68, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetWeight",904,G__G__Tree_113_0_128, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetZipBytes",1114,G__G__Tree_113_0_129, 110, -1, G__defined_typename("Long64_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("IncrementTotalBuffers",2166,G__G__Tree_113_0_130, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - nbytes", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("IsFolder",792,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("LoadBaskets",1101,G__G__Tree_113_0_132, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "n - 'Long64_t' 0 '2000000000' maxmemory", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("LoadTree",784,G__G__Tree_113_0_133, 110, -1, G__defined_typename("Long64_t"), 0, 1, 1, 1, 0, "n - 'Long64_t' 0 - entry", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("LoadTreeFriend",1384,G__G__Tree_113_0_134, 110, -1, G__defined_typename("Long64_t"), 0, 2, 1, 1, 0, 
"n - 'Long64_t' 0 - entry U 'TTree' - 0 - T", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("MakeClass",884,G__G__Tree_113_0_135, 105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 0, 
"C - - 10 '0' classname C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("MakeCode",761,G__G__Tree_113_0_136, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "C - - 10 '0' filename", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("MakeProxy",928,G__G__Tree_113_0_137, 105, -1, G__defined_typename("Int_t"), 0, 5, 1, 1, 0, 
"C - - 10 - classname C - - 10 '0' macrofilename "
"C - - 10 '0' cutfilename C - - 10 '0' option "
"i - 'Int_t' 0 '3' maxUnrolling", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("MakeSelector",1215,G__G__Tree_113_0_138, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "C - - 10 '0' selector", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("MemoryFull",1036,G__G__Tree_113_0_139, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "i - 'Int_t' 0 - nbytes", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Merge",496,G__G__Tree_113_0_140, 110, -1, G__defined_typename("Long64_t"), 0, 2, 1, 1, 0, 
"U 'TCollection' - 0 - list C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("MergeTrees",1011,G__G__Tree_113_0_141, 85, G__get_linked_tagnum(&G__G__TreeLN_TTree), -1, 0, 2, 3, 1, 0, 
"U 'TList' - 0 - list C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) G__func2void( (TTree* (*)(TList*, Option_t*))(&TTree::MergeTrees) ), 0);
   G__memfunc_setup("Notify",633,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("OptimizeBaskets",1566,G__G__Tree_113_0_143, 121, -1, -1, 0, 3, 1, 1, 0, 
"m - 'ULong64_t' 0 '10000000' maxMemory f - 'Float_t' 0 '1.1' minComp "
"C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Principal",930,G__G__Tree_113_0_144, 85, G__get_linked_tagnum(&G__G__TreeLN_TPrincipal), -1, 0, 5, 1, 1, 0, 
"C - - 10 '\"\"' varexp C - - 10 '\"\"' selection "
"C - 'Option_t' 10 '\"np\"' option n - 'Long64_t' 0 '1000000000' nentries "
"n - 'Long64_t' 0 '0' firstentry", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Print",525,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "C - 'Option_t' 10 '\"\"' option", "*MENU*", (void*) NULL, 1);
   G__memfunc_setup("PrintCacheStats",1520,G__G__Tree_113_0_146, 121, -1, -1, 0, 1, 1, 1, 8, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Process",735,G__G__Tree_113_0_147, 110, -1, G__defined_typename("Long64_t"), 0, 4, 1, 1, 0, 
"C - - 10 - filename C - 'Option_t' 10 '\"\"' option "
"n - 'Long64_t' 0 '1000000000' nentries n - 'Long64_t' 0 '0' firstentry", "*MENU*", (void*) NULL, 1);
   G__memfunc_setup("Project",727,G__G__Tree_113_0_148, 110, -1, G__defined_typename("Long64_t"), 0, 6, 1, 1, 0, 
"C - - 10 - hname C - - 10 - varexp "
"C - - 10 '\"\"' selection C - 'Option_t' 10 '\"\"' option "
"n - 'Long64_t' 0 '1000000000' nentries n - 'Long64_t' 0 '0' firstentry", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Query",534,G__G__Tree_113_0_149, 85, G__get_linked_tagnum(&G__G__TreeLN_TSQLResult), -1, 0, 5, 1, 1, 0, 
"C - - 10 '\"\"' varexp C - - 10 '\"\"' selection "
"C - 'Option_t' 10 '\"\"' option n - 'Long64_t' 0 '1000000000' nentries "
"n - 'Long64_t' 0 '0' firstentry", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ReadFile",764,G__G__Tree_113_0_150, 110, -1, G__defined_typename("Long64_t"), 0, 2, 1, 1, 0, 
"C - - 10 - filename C - - 10 '\"\"' branchDescriptor", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ReadStream",1000,G__G__Tree_113_0_151, 110, -1, G__defined_typename("Long64_t"), 0, 2, 1, 1, 0, 
"u 'basic_istream<char,char_traits<char> >' 'istream' 1 - inputStream C - - 10 '\"\"' branchDescriptor", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Refresh",719,G__G__Tree_113_0_152, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("RecursiveRemove",1574,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TObject' - 0 - obj", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("RemoveFriend",1222,G__G__Tree_113_0_154, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TTree' - 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Reset",515,G__G__Tree_113_0_155, 121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ResetBranchAddress",1815,G__G__Tree_113_0_156, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TBranch' - 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ResetBranchAddresses",2031,G__G__Tree_113_0_157, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Scan",389,G__G__Tree_113_0_158, 110, -1, G__defined_typename("Long64_t"), 0, 5, 1, 1, 0, 
"C - - 10 '\"\"' varexp C - - 10 '\"\"' selection "
"C - 'Option_t' 10 '\"\"' option n - 'Long64_t' 0 '1000000000' nentries "
"n - 'Long64_t' 0 '0' firstentry", "*MENU*", (void*) NULL, 1);
   G__memfunc_setup("SetAlias",790,G__G__Tree_113_0_159, 103, -1, G__defined_typename("Bool_t"), 0, 2, 1, 1, 0, 
"C - - 10 - aliasName C - - 10 - aliasFormula", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetAutoSave",1108,G__G__Tree_113_0_160, 121, -1, -1, 0, 1, 1, 1, 0, "n - 'Long64_t' 0 '300000000' autos", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetAutoFlush",1223,G__G__Tree_113_0_161, 121, -1, -1, 0, 1, 1, 1, 0, "n - 'Long64_t' 0 '30000000' autof", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetBasketSize",1313,G__G__Tree_113_0_162, 121, -1, -1, 0, 2, 1, 1, 0, 
"C - - 10 - bname i - 'Int_t' 0 '16000' buffsize", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetBranchAddress",1600,G__G__Tree_113_0_163, 105, -1, G__defined_typename("Int_t"), 0, 5, 1, 1, 0, 
"C - - 10 - bname Y - - 0 - add "
"U 'TClass' - 0 - realClass i 'EDataType' - 0 - datatype "
"g - 'Bool_t' 0 - isptr", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetBranchAddress",1600,G__G__Tree_113_0_164, 105, -1, G__defined_typename("Int_t"), 0, 6, 1, 1, 0, 
"C - - 10 - bname Y - - 0 - add "
"U 'TBranch' - 2 - ptr U 'TClass' - 0 - realClass "
"i 'EDataType' - 0 - datatype g - 'Bool_t' 0 - isptr", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetBranchStatus",1534,G__G__Tree_113_0_165, 121, -1, -1, 0, 3, 1, 1, 0, 
"C - - 10 - bname g - 'Bool_t' 0 '1' status "
"H - 'UInt_t' 0 '0' found", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetBranchStyle",1419,G__G__Tree_113_0_166, 121, -1, -1, 0, 1, 3, 1, 0, "i - 'Int_t' 0 '1' style", "style=0 for old branch, =1 for new branch style", (void*) G__func2void( (void (*)(Int_t))(&TTree::SetBranchStyle) ), 0);
   G__memfunc_setup("SetCacheSize",1179,G__G__Tree_113_0_167, 121, -1, -1, 0, 1, 1, 1, 0, "n - 'Long64_t' 0 '-1' cachesize", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetCacheEntryRange",1791,G__G__Tree_113_0_168, 121, -1, -1, 0, 2, 1, 1, 0, 
"n - 'Long64_t' 0 - first n - 'Long64_t' 0 - last", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetCacheLearnEntries",1996,G__G__Tree_113_0_169, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 '10' n", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetChainOffset",1398,G__G__Tree_113_0_170, 121, -1, -1, 0, 1, 1, 1, 0, "n - 'Long64_t' 0 '0' offset", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetCircular",1121,G__G__Tree_113_0_171, 121, -1, -1, 0, 1, 1, 1, 0, "n - 'Long64_t' 0 - maxEntries", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetDebug",787,G__G__Tree_113_0_172, 121, -1, -1, 0, 3, 1, 1, 0, 
"i - 'Int_t' 0 '1' level n - 'Long64_t' 0 '0' min "
"n - 'Long64_t' 0 '9999999' max", "*MENU*", (void*) NULL, 1);
   G__memfunc_setup("SetDefaultEntryOffsetLen",2441,G__G__Tree_113_0_173, 121, -1, -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - newdefault g - 'Bool_t' 0 'kFALSE' updateExisting", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetDirectory",1249,G__G__Tree_113_0_174, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TDirectory' - 0 - dir", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetEntries",1030,G__G__Tree_113_0_175, 110, -1, G__defined_typename("Long64_t"), 0, 1, 1, 1, 0, "n - 'Long64_t' 0 '-1' n", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetEstimate",1128,G__G__Tree_113_0_176, 121, -1, -1, 0, 1, 1, 1, 0, "n - 'Long64_t' 0 '10000' nentries", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetFileNumber",1301,G__G__Tree_113_0_177, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 '0' number", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetEventList",1226,G__G__Tree_113_0_178, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TEventList' - 0 - list", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetEntryList",1242,G__G__Tree_113_0_179, 121, -1, -1, 0, 2, 1, 1, 0, 
"U 'TEntryList' - 0 - list C - 'Option_t' 10 '\"\"' opt", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetMakeClass",1184,G__G__Tree_113_0_180, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - make", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetMaxEntryLoop",1534,G__G__Tree_113_0_181, 121, -1, -1, 0, 1, 1, 1, 0, "n - 'Long64_t' 0 '1000000000' maxev", "*MENU*", (void*) NULL, 1);
   G__memfunc_setup("SetMaxTreeSize",1405,G__G__Tree_113_0_182, 121, -1, -1, 0, 1, 3, 1, 0, "n - 'Long64_t' 0 '1900000000' maxsize", (char*)NULL, (void*) G__func2void( (void (*)(Long64_t))(&TTree::SetMaxTreeSize) ), 0);
   G__memfunc_setup("SetMaxVirtualSize",1748,G__G__Tree_113_0_183, 121, -1, -1, 0, 1, 1, 1, 0, "n - 'Long64_t' 0 '0' size", "*MENU*", (void*) NULL, 1);
   G__memfunc_setup("SetName",685,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - name", "*MENU*", (void*) NULL, 1);
   G__memfunc_setup("SetNotify",933,G__G__Tree_113_0_185, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TObject' - 0 - obj", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetObject",899,G__G__Tree_113_0_186, 121, -1, -1, 0, 2, 1, 1, 0, 
"C - - 10 - name C - - 10 - title", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetParallelUnzip",1647,G__G__Tree_113_0_187, 121, -1, -1, 0, 2, 1, 1, 0, 
"g - 'Bool_t' 0 'kTRUE' opt f - 'Float_t' 0 '-1' RelSize", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetScanField",1173,G__G__Tree_113_0_188, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 '50' n", "*MENU*", (void*) NULL, 1);
   G__memfunc_setup("SetTimerInterval",1650,G__G__Tree_113_0_189, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 '333' msec", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetTreeIndex",1204,G__G__Tree_113_0_190, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TVirtualIndex' - 0 - index", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetWeight",916,G__G__Tree_113_0_191, 121, -1, -1, 0, 2, 1, 1, 0, 
"d - 'Double_t' 0 '1' w C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetUpdate",911,G__G__Tree_113_0_192, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 '0' freq", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Show",417,G__G__Tree_113_0_193, 121, -1, -1, 0, 2, 1, 1, 0, 
"n - 'Long64_t' 0 '-1' entry i - 'Int_t' 0 '20' lenmax", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StartViewer",1152,G__G__Tree_113_0_194, 121, -1, -1, 0, 0, 1, 1, 0, "", "*MENU*", (void*) NULL, 1);
   G__memfunc_setup("StopCacheLearningPhase",2203,G__G__Tree_113_0_195, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("UnbinnedFit",1110,G__G__Tree_113_0_196, 105, -1, G__defined_typename("Int_t"), 0, 6, 1, 1, 0, 
"C - - 10 - funcname C - - 10 - varexp "
"C - - 10 '\"\"' selection C - 'Option_t' 10 '\"\"' option "
"n - 'Long64_t' 0 '1000000000' nentries n - 'Long64_t' 0 '0' firstentry", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("UseCurrentStyle",1569,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Write",523,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 3, 1, 1, 0, 
"C - - 10 '0' name i - 'Int_t' 0 '0' option "
"i - 'Int_t' 0 '0' bufsize", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Write",523,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 3, 1, 1, 8, 
"C - - 10 '0' name i - 'Int_t' 0 '0' option "
"i - 'Int_t' 0 '0' bufsize", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Tree_113_0_200, 85, G__get_linked_tagnum(&G__G__TreeLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TTree::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Tree_113_0_201, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TTree::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Tree_113_0_202, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TTree::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Tree_113_0_203, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TTree::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__TreeLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (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__G__Tree_113_0_207, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Tree_113_0_208, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TTree::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Tree_113_0_209, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TTree::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Tree_113_0_210, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TTree::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Tree_113_0_211, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TTree::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TTree", 610, G__G__Tree_113_0_212, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTBranch(void) {
   /* TBranch */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__TreeLN_TBranch));
   G__memfunc_setup("ReadLeavesImpl",1390,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetSkipZip",1014,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 0, "g - 'Bool_t' 0 'kTRUE' skip", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Init",404,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 3, 1, 2, 0, 
"C - - 10 - name C - - 10 - leaflist "
"i - 'Int_t' 0 - compress", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetFreshBasket",1394,(G__InterfaceMethod) NULL, 85, G__get_linked_tagnum(&G__G__TreeLN_TBasket), -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("WriteBasket",1125,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 2, 1, 2, 0, 
"U 'TBasket' - 0 - basket i - 'Int_t' 0 - where", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetRealFileName",1445,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__TreeLN_TString), -1, 0, 0, 1, 2, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TBranch",674,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__TreeLN_TBranch), -1, 0, 1, 1, 4, 0, "u 'TBranch' - 11 - -", "not implemented", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__TreeLN_TBranch), -1, 1, 1, 1, 4, 0, "u 'TBranch' - 11 - -", "not implemented", (void*) NULL, 0);
   G__memfunc_setup("TBranch",674,G__G__Tree_114_0_9, 105, G__get_linked_tagnum(&G__G__TreeLN_TBranch), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TBranch",674,G__G__Tree_114_0_10, 105, G__get_linked_tagnum(&G__G__TreeLN_TBranch), -1, 0, 6, 1, 1, 0, 
"U 'TTree' - 0 - tree C - - 10 - name "
"Y - - 0 - address C - - 10 - leaflist "
"i - 'Int_t' 0 '32000' basketsize i - 'Int_t' 0 '-1' compress", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TBranch",674,G__G__Tree_114_0_11, 105, G__get_linked_tagnum(&G__G__TreeLN_TBranch), -1, 0, 6, 1, 1, 0, 
"U 'TBranch' - 0 - parent C - - 10 - name "
"Y - - 0 - address C - - 10 - leaflist "
"i - 'Int_t' 0 '32000' basketsize i - 'Int_t' 0 '-1' compress", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddBasket",867,G__G__Tree_114_0_12, 121, -1, -1, 0, 3, 1, 1, 0, 
"u 'TBasket' - 1 - b g - 'Bool_t' 0 - ondisk "
"n - 'Long64_t' 0 - startEntry", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("AddLastBasket",1271,G__G__Tree_114_0_13, 121, -1, -1, 0, 1, 1, 1, 0, "n - 'Long64_t' 0 - startEntry", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Browse",626,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TBrowser' - 0 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DeleteBaskets",1312,G__G__Tree_114_0_15, 121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DropBaskets",1122,G__G__Tree_114_0_16, 121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ExpandBasketArrays",1836,G__G__Tree_114_0_17, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Fill",391,G__G__Tree_114_0_18, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("FillLeaves",999,G__G__Tree_114_0_19, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("FindBranch",975,G__G__Tree_114_0_20, 85, G__get_linked_tagnum(&G__G__TreeLN_TBranch), -1, 0, 1, 1, 1, 0, "C - - 10 - name", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("FindLeaf",761,G__G__Tree_114_0_21, 85, G__get_linked_tagnum(&G__G__TreeLN_TLeaf), -1, 0, 1, 1, 1, 0, "C - - 10 - name", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("FlushBaskets",1231,G__G__Tree_114_0_22, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("FlushOneBasket",1406,G__G__Tree_114_0_23, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "h - 'UInt_t' 0 - which", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetAddress",998,G__G__Tree_114_0_24, 67, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetBasket",890,G__G__Tree_114_0_25, 85, G__get_linked_tagnum(&G__G__TreeLN_TBasket), -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - basket", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetBasketBytes",1409,G__G__Tree_114_0_26, 73, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetBasketEntry",1420,G__G__Tree_114_0_27, 78, -1, G__defined_typename("Long64_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetBasketSeek",1282,G__G__Tree_114_0_28, 110, -1, G__defined_typename("Long64_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 0 - basket", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetBasketSize",1301,G__G__Tree_114_0_29, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetBrowsables",1332,G__G__Tree_114_0_30, 85, G__get_linked_tagnum(&G__G__TreeLN_TList), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetClassName",1175,G__G__Tree_114_0_31, 67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetCompressionLevel",1962,G__G__Tree_114_0_32, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetDirectory",1237,G__G__Tree_114_0_33, 85, G__get_linked_tagnum(&G__G__TreeLN_TDirectory), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetEntry",818,G__G__Tree_114_0_34, 105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 0, 
"n - 'Long64_t' 0 '0' entry i - 'Int_t' 0 '0' getall", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetEntryExport",1460,G__G__Tree_114_0_35, 105, -1, G__defined_typename("Int_t"), 0, 4, 1, 1, 0, 
"n - 'Long64_t' 0 - entry i - 'Int_t' 0 - getall "
"U 'TClonesArray' - 0 - list i - 'Int_t' 0 - n", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetEntryOffsetLen",1720,G__G__Tree_114_0_36, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetEvent",802,G__G__Tree_114_0_37, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "n - 'Long64_t' 0 '0' entry", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetIconName",1066,(G__InterfaceMethod) NULL,67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetExpectedType",1524,G__G__Tree_114_0_39, 105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 0, 
"U 'TClass' - 1 - clptr i 'EDataType' - 1 - type", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetLeaf",664,G__G__Tree_114_0_40, 85, G__get_linked_tagnum(&G__G__TreeLN_TLeaf), -1, 0, 1, 1, 1, 8, "C - - 10 - name", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetFile",672,G__G__Tree_114_0_41, 85, G__get_linked_tagnum(&G__G__TreeLN_TFile), -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 '0' mode", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetFileName",1057,G__G__Tree_114_0_42, 67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetOffset",903,G__G__Tree_114_0_43, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetReadBasket",1270,G__G__Tree_114_0_44, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetReadEntry",1198,G__G__Tree_114_0_45, 110, -1, G__defined_typename("Long64_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetWriteBasket",1413,G__G__Tree_114_0_46, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetTotalSize",1215,G__G__Tree_114_0_47, 110, -1, G__defined_typename("Long64_t"), 0, 1, 1, 1, 8, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetTotBytes",1118,G__G__Tree_114_0_48, 110, -1, G__defined_typename("Long64_t"), 0, 1, 1, 1, 8, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetZipBytes",1114,G__G__Tree_114_0_49, 110, -1, G__defined_typename("Long64_t"), 0, 1, 1, 1, 8, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetEntryNumber",1435,G__G__Tree_114_0_50, 110, -1, G__defined_typename("Long64_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetFirstEntry",1338,G__G__Tree_114_0_51, 110, -1, G__defined_typename("Long64_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetListOfBaskets",1598,G__G__Tree_114_0_52, 85, G__get_linked_tagnum(&G__G__TreeLN_TObjArray), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetListOfBranches",1687,G__G__Tree_114_0_53, 85, G__get_linked_tagnum(&G__G__TreeLN_TObjArray), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetListOfLeaves",1489,G__G__Tree_114_0_54, 85, G__get_linked_tagnum(&G__G__TreeLN_TObjArray), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMaxBaskets",1299,G__G__Tree_114_0_55, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetNleaves",1006,G__G__Tree_114_0_56, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetSplitLevel",1316,G__G__Tree_114_0_57, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetEntries",1018,G__G__Tree_114_0_58, 110, -1, G__defined_typename("Long64_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetTree",688,G__G__Tree_114_0_59, 85, G__get_linked_tagnum(&G__G__TreeLN_TTree), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetRow",600,G__G__Tree_114_0_60, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "i - 'Int_t' 0 - row", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetMakeClass",1172,G__G__Tree_114_0_61, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetMother",911,G__G__Tree_114_0_62, 85, G__get_linked_tagnum(&G__G__TreeLN_TBranch), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetSubBranch",1176,G__G__Tree_114_0_63, 85, G__get_linked_tagnum(&G__G__TreeLN_TBranch), -1, 0, 1, 1, 1, 8, "U 'TBranch' - 10 - br", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsAutoDelete",1192,G__G__Tree_114_0_64, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsFolder",792,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("KeepCircular",1210,G__G__Tree_114_0_66, 121, -1, -1, 0, 1, 1, 1, 0, "n - 'Long64_t' 0 - maxEntries", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("LoadBaskets",1101,G__G__Tree_114_0_67, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Print",525,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ReadBasket",982,G__G__Tree_114_0_69, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Refresh",719,G__G__Tree_114_0_70, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TBranch' - 0 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Reset",515,G__G__Tree_114_0_71, 121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ResetAddress",1225,G__G__Tree_114_0_72, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ResetReadEntry",1425,G__G__Tree_114_0_73, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetAddress",1010,G__G__Tree_114_0_74, 121, -1, -1, 0, 1, 1, 1, 0, "Y - - 0 - add", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetObject",899,G__G__Tree_114_0_75, 121, -1, -1, 0, 1, 1, 1, 0, "Y - - 0 - objadd", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetAutoDelete",1304,G__G__Tree_114_0_76, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kTRUE' autodel", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetBasketSize",1313,G__G__Tree_114_0_77, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - buffsize", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetBufferAddress",1612,G__G__Tree_114_0_78, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TBuffer' - 0 - entryBuffer", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetCompressionLevel",1974,G__G__Tree_114_0_79, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 '1' level", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetEntries",1030,G__G__Tree_114_0_80, 121, -1, -1, 0, 1, 1, 1, 0, "n - 'Long64_t' 0 - entries", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetEntryOffsetLen",1732,G__G__Tree_114_0_81, 121, -1, -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - len g - 'Bool_t' 0 'kFALSE' updateSubBranches", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetFirstEntry",1350,G__G__Tree_114_0_82, 121, -1, -1, 0, 1, 1, 1, 0, "n - 'Long64_t' 0 - entry", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetFile",684,G__G__Tree_114_0_83, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TFile' - 0 '0' file", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetFile",684,G__G__Tree_114_0_84, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - filename", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetMakeClass",1184,G__G__Tree_114_0_85, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kTRUE' decomposeObj", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetOffset",915,G__G__Tree_114_0_86, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 '0' offset", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetStatus",944,G__G__Tree_114_0_87, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 '1' status", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetTree",700,G__G__Tree_114_0_88, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TTree' - 0 - tree", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetupAddresses",1455,G__G__Tree_114_0_89, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("UpdateAddress",1321,G__G__Tree_114_0_90, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("UpdateFile",995,G__G__Tree_114_0_91, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ResetCount",1036,G__G__Tree_114_0_92, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TBranch::ResetCount) ), 0);
   G__memfunc_setup("Class",502,G__G__Tree_114_0_93, 85, G__get_linked_tagnum(&G__G__TreeLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TBranch::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Tree_114_0_94, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TBranch::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Tree_114_0_95, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TBranch::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Tree_114_0_96, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TBranch::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__TreeLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (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__G__Tree_114_0_100, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Tree_114_0_101, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TBranch::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Tree_114_0_102, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TBranch::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Tree_114_0_103, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TBranch::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Tree_114_0_104, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TBranch::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TBranch", 800, G__G__Tree_114_0_105, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTBasket(void) {
   /* TBasket */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__TreeLN_TBasket));
   G__memfunc_setup("TBasket",686,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__TreeLN_TBasket), -1, 0, 1, 1, 4, 0, "u 'TBasket' - 11 - -", "TBasket objects are not copiable.", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__TreeLN_TBasket), -1, 1, 1, 1, 4, 0, "u 'TBasket' - 11 - -", "TBasket objects are not copiable.", (void*) NULL, 0);
   G__memfunc_setup("TBasket",686,G__G__Tree_115_0_3, 105, G__get_linked_tagnum(&G__G__TreeLN_TBasket), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TBasket",686,G__G__Tree_115_0_4, 105, G__get_linked_tagnum(&G__G__TreeLN_TBasket), -1, 0, 1, 1, 1, 0, "U 'TDirectory' - 0 - motherDir", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TBasket",686,G__G__Tree_115_0_5, 105, G__get_linked_tagnum(&G__G__TreeLN_TBasket), -1, 0, 3, 1, 1, 0, 
"C - - 10 - name C - - 10 - title "
"U 'TBranch' - 0 - branch", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AdjustSize",1030,G__G__Tree_115_0_6, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - newsize", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DeleteEntryOffset",1740,G__G__Tree_115_0_7, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DropBuffers",1122,G__G__Tree_115_0_8, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetBranch",878,G__G__Tree_115_0_9, 85, G__get_linked_tagnum(&G__G__TreeLN_TBranch), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetBufferSize",1301,G__G__Tree_115_0_10, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetDisplacement",1529,G__G__Tree_115_0_11, 73, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetEntryOffset",1433,G__G__Tree_115_0_12, 73, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetEntryPointer",1555,G__G__Tree_115_0_13, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "i - 'Int_t' 0 - Entry", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetNevBuf",870,G__G__Tree_115_0_14, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetNevBufSize",1281,G__G__Tree_115_0_15, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetLast",692,G__G__Tree_115_0_16, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MoveEntries",1137,G__G__Tree_115_0_17, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - dentries", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("PrepareBasket",1321,G__G__Tree_115_0_18, 121, -1, -1, 0, 1, 1, 1, 0, "n - 'Long64_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ReadBasketBuffers",1699,G__G__Tree_115_0_19, 105, -1, G__defined_typename("Int_t"), 0, 3, 1, 1, 0, 
"n - 'Long64_t' 0 - pos i - 'Int_t' 0 - len "
"U 'TFile' - 0 - file", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ReadBasketBytes",1501,G__G__Tree_115_0_20, 105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 0, 
"n - 'Long64_t' 0 - pos U 'TFile' - 0 - file", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Reset",515,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("LoadBasketBuffers",1703,G__G__Tree_115_0_22, 105, -1, G__defined_typename("Int_t"), 0, 3, 1, 1, 0, 
"n - 'Long64_t' 0 - pos i - 'Int_t' 0 - len "
"U 'TFile' - 0 - file", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CopyTo",606,G__G__Tree_115_0_23, 110, -1, G__defined_typename("Long64_t"), 0, 1, 1, 1, 0, "U 'TFile' - 0 - to", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetBranch",890,G__G__Tree_115_0_24, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TBranch' - 0 - branch", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetNevBufSize",1293,G__G__Tree_115_0_25, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - n", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetReadMode",1069,G__G__Tree_115_0_26, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetWriteMode",1212,G__G__Tree_115_0_27, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Update",611,G__G__Tree_115_0_28, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - newlast", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Update",611,G__G__Tree_115_0_29, 121, -1, -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - newlast i - 'Int_t' 0 - skipped", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("WriteBuffer",1125,G__G__Tree_115_0_30, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Tree_115_0_31, 85, G__get_linked_tagnum(&G__G__TreeLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TBasket::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Tree_115_0_32, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TBasket::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Tree_115_0_33, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TBasket::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Tree_115_0_34, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TBasket::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__TreeLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (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__G__Tree_115_0_38, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Tree_115_0_39, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TBasket::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Tree_115_0_40, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TBasket::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Tree_115_0_41, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TBasket::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Tree_115_0_42, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TBasket::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TBasket", 812, G__G__Tree_115_0_43, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTBufferSQL(void) {
   /* TBufferSQL */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__TreeLN_TBufferSQL));
   G__memfunc_setup("TBufferSQL",926,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__TreeLN_TBufferSQL), -1, 0, 1, 1, 4, 0, "u 'TBufferSQL' - 11 - -", "not implemented", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "u 'TBufferSQL' - 11 - -", "not implemented", (void*) NULL, 0);
   G__memfunc_setup("TBufferSQL",926,G__G__Tree_118_0_3, 105, G__get_linked_tagnum(&G__G__TreeLN_TBufferSQL), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TBufferSQL",926,G__G__Tree_118_0_4, 105, G__get_linked_tagnum(&G__G__TreeLN_TBufferSQL), -1, 0, 4, 1, 1, 0, 
"i 'TBuffer::EMode' - 0 - mode U 'vector<int,allocator<int> >' 'vector<Int_t>' 0 - vc "
"U 'TString' - 0 - insert_query U 'TSQLRow' - 2 - rowPtr", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TBufferSQL",926,G__G__Tree_118_0_5, 105, G__get_linked_tagnum(&G__G__TreeLN_TBufferSQL), -1, 0, 5, 1, 1, 0, 
"i 'TBuffer::EMode' - 0 - mode i - 'Int_t' 0 - bufsiz "
"U 'vector<int,allocator<int> >' 'vector<Int_t>' 0 - vc U 'TString' - 0 - insert_query "
"U 'TSQLRow' - 2 - rowPtr", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TBufferSQL",926,G__G__Tree_118_0_6, 105, G__get_linked_tagnum(&G__G__TreeLN_TBufferSQL), -1, 0, 7, 1, 1, 0, 
"i 'TBuffer::EMode' - 0 - mode i - 'Int_t' 0 - bufsiz "
"U 'vector<int,allocator<int> >' 'vector<Int_t>' 0 - vc U 'TString' - 0 - insert_query "
"U 'TSQLRow' - 2 - rowPtr Y - - 0 - buf "
"g - 'Bool_t' 0 'kTRUE' adopt", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ResetOffset",1130,G__G__Tree_118_0_7, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ReadBool",776,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ReadChar",762,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "c - 'Char_t' 1 - c", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ReadUChar",847,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "b - 'UChar_t' 1 - c", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ReadShort",908,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "s - 'Short_t' 1 - s", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ReadUShort",993,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "r - 'UShort_t' 1 - s", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ReadInt",679,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 1 - i", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ReadUInt",764,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "h - 'UInt_t' 1 - i", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ReadLong",780,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "l - 'Long_t' 1 - l", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ReadULong",865,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "k - 'ULong_t' 1 - l", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ReadLong64",886,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "n - 'Long64_t' 1 - l", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ReadULong64",971,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "m - 'ULong64_t' 1 - l", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ReadFloat",882,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "f - 'Float_t' 1 - f", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ReadDouble",983,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 1 - d", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ReadCharP",842,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Char_t' 0 - c", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ReadTString",1095,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TString' - 1 - s", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("WriteBool",919,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("WriteChar",905,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "c - 'Char_t' 0 - c", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("WriteUChar",990,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "b - 'UChar_t' 0 - c", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("WriteShort",1051,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "s - 'Short_t' 0 - s", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("WriteUShort",1136,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "r - 'UShort_t' 0 - s", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("WriteInt",822,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("WriteUInt",907,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "h - 'UInt_t' 0 - i", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("WriteLong",923,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "l - 'Long_t' 0 - l", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("WriteULong",1008,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "k - 'ULong_t' 0 - l", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("WriteLong64",1029,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "n - 'Long64_t' 0 - l", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("WriteULong64",1114,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "m - 'ULong64_t' 0 - l", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("WriteFloat",1025,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "f - 'Float_t' 0 - f", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("WriteDouble",1126,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - d", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("WriteCharP",985,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Char_t' 10 - c", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("WriteTString",1238,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TString' - 11 - s", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("WriteFastArray",1432,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"G - 'Bool_t' 10 - b i - 'Int_t' 0 - n", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("WriteFastArray",1432,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"C - 'Char_t' 10 - c i - 'Int_t' 0 - n", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("WriteFastArrayString",2063,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"C - 'Char_t' 10 - c i - 'Int_t' 0 - n", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("WriteFastArray",1432,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"B - 'UChar_t' 10 - c i - 'Int_t' 0 - n", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("WriteFastArray",1432,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"S - 'Short_t' 10 - h i - 'Int_t' 0 - n", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("WriteFastArray",1432,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"R - 'UShort_t' 10 - h i - 'Int_t' 0 - n", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("WriteFastArray",1432,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"I - 'Int_t' 10 - i i - 'Int_t' 0 - n", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("WriteFastArray",1432,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"H - 'UInt_t' 10 - i i - 'Int_t' 0 - n", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("WriteFastArray",1432,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"L - 'Long_t' 10 - l i - 'Int_t' 0 - n", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("WriteFastArray",1432,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"K - 'ULong_t' 10 - l i - 'Int_t' 0 - n", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("WriteFastArray",1432,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"N - 'Long64_t' 10 - l i - 'Int_t' 0 - n", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("WriteFastArray",1432,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"M - 'ULong64_t' 10 - l i - 'Int_t' 0 - n", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("WriteFastArray",1432,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"F - 'Float_t' 10 - f i - 'Int_t' 0 - n", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("WriteFastArray",1432,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"D - 'Double_t' 10 - d i - 'Int_t' 0 - n", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("WriteFastArray",1432,(G__InterfaceMethod) NULL,121, -1, -1, 0, 4, 1, 1, 0, 
"Y - - 0 - start U 'TClass' - 10 - cl "
"i - 'Int_t' 0 '1' n U 'TMemberStreamer' - 0 '0' s", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("WriteFastArray",1432,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 5, 1, 1, 0, 
"Y - - 2 - startp U 'TClass' - 10 - cl "
"i - 'Int_t' 0 '1' n g - 'Bool_t' 0 'kFALSE' isPreAlloc "
"U 'TMemberStreamer' - 0 '0' s", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ReadFastArray",1289,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"G - 'Bool_t' 0 - - i - 'Int_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ReadFastArray",1289,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"C - 'Char_t' 0 - - i - 'Int_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ReadFastArrayString",1920,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"C - 'Char_t' 0 - - i - 'Int_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ReadFastArray",1289,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"B - 'UChar_t' 0 - - i - 'Int_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ReadFastArray",1289,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"S - 'Short_t' 0 - - i - 'Int_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ReadFastArray",1289,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"R - 'UShort_t' 0 - - i - 'Int_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ReadFastArray",1289,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"I - 'Int_t' 0 - - i - 'Int_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ReadFastArray",1289,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"H - 'UInt_t' 0 - - i - 'Int_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ReadFastArray",1289,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"L - 'Long_t' 0 - - i - 'Int_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ReadFastArray",1289,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"K - 'ULong_t' 0 - - i - 'Int_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ReadFastArray",1289,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"N - 'Long64_t' 0 - - i - 'Int_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ReadFastArray",1289,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"M - 'ULong64_t' 0 - - i - 'Int_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ReadFastArray",1289,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"F - 'Float_t' 0 - - i - 'Int_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ReadFastArray",1289,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"D - 'Double_t' 0 - - i - 'Int_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ReadFastArrayFloat16",1894,(G__InterfaceMethod) NULL,121, -1, -1, 0, 3, 1, 1, 0, 
"F - 'Float_t' 0 - f i - 'Int_t' 0 - n "
"U 'TStreamerElement' - 0 '0' ele", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ReadFastArrayDouble32",1993,(G__InterfaceMethod) NULL,121, -1, -1, 0, 3, 1, 1, 0, 
"D - 'Double_t' 0 - d i - 'Int_t' 0 - n "
"U 'TStreamerElement' - 0 '0' ele", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ReadFastArray",1289,(G__InterfaceMethod) NULL,121, -1, -1, 0, 5, 1, 1, 0, 
"Y - - 0 - - U 'TClass' - 10 - - "
"i - 'Int_t' 0 '1' n U 'TMemberStreamer' - 0 '0' s "
"U 'TClass' - 10 '0' onFileClass", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ReadFastArray",1289,(G__InterfaceMethod) NULL,121, -1, -1, 0, 6, 1, 1, 0, 
"Y - - 2 - - U 'TClass' - 10 - - "
"i - 'Int_t' 0 '1' n g - 'Bool_t' 0 'kFALSE' isPreAlloc "
"U 'TMemberStreamer' - 0 '0' s U 'TClass' - 10 '0' onFileClass", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Tree_118_0_72, 85, G__get_linked_tagnum(&G__G__TreeLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TBufferSQL::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Tree_118_0_73, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TBufferSQL::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Tree_118_0_74, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TBufferSQL::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Tree_118_0_75, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TBufferSQL::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__TreeLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (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__G__Tree_118_0_79, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Tree_118_0_80, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TBufferSQL::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Tree_118_0_81, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TBufferSQL::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Tree_118_0_82, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TBufferSQL::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Tree_118_0_83, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TBufferSQL::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TBufferSQL", 1052, G__G__Tree_118_0_84, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTBasketSQL(void) {
   /* TBasketSQL */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__TreeLN_TBasketSQL));
   G__memfunc_setup("TBasketSQL",926,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__TreeLN_TBasketSQL), -1, 0, 1, 1, 4, 0, "u 'TBasketSQL' - 11 - -", "TBasketSQL objects are not copiable.", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__TreeLN_TBasketSQL), -1, 1, 1, 1, 4, 0, "u 'TBasketSQL' - 11 - -", "TBasketSQL objects are not copiable.", (void*) NULL, 0);
   G__memfunc_setup("TBasketSQL",926,G__G__Tree_119_0_3, 105, G__get_linked_tagnum(&G__G__TreeLN_TBasketSQL), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TBasketSQL",926,G__G__Tree_119_0_4, 105, G__get_linked_tagnum(&G__G__TreeLN_TBasketSQL), -1, 0, 7, 1, 1, 0, 
"C - - 10 - name C - - 10 - title "
"U 'TBranch' - 0 - branch U 'TSQLResult' - 2 - rs "
"U 'TString' - 0 - insert_query U 'vector<int,allocator<int> >' 'vector<Int_t>' 0 - vc "
"U 'TSQLRow' - 2 - row", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("PrepareBasket",1321,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "n - 'Long64_t' 0 - entry", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ReadBasketBuffers",1699,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 3, 1, 1, 0, 
"n - 'Long64_t' 0 - pos i - 'Int_t' 0 - len "
"U 'TFile' - 0 - file", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ReadBasketBytes",1501,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 0, 
"n - 'Long64_t' 0 - pos U 'TFile' - 0 - file", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Reset",515,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetResultSet",1227,G__G__Tree_119_0_9, 85, G__get_linked_tagnum(&G__G__TreeLN_TSQLResult), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CreateBuffer",1198,G__G__Tree_119_0_10, 121, -1, -1, 0, 5, 1, 1, 0, 
"C - - 10 - name u 'TString' - 0 - title "
"U 'vector<int,allocator<int> >' 'vector<Int_t>' 0 - vc U 'TBranch' - 0 - branch "
"U 'TSQLResult' - 2 - rs", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Update",611,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - offset i - 'Int_t' 0 - skipped", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Tree_119_0_12, 85, G__get_linked_tagnum(&G__G__TreeLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TBasketSQL::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Tree_119_0_13, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TBasketSQL::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Tree_119_0_14, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TBasketSQL::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Tree_119_0_15, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TBasketSQL::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__TreeLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (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__G__Tree_119_0_19, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Tree_119_0_20, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TBasketSQL::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Tree_119_0_21, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TBasketSQL::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Tree_119_0_22, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TBasketSQL::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Tree_119_0_23, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TBasketSQL::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TBasketSQL", 1052, G__G__Tree_119_0_24, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTBranchElement(void) {
   /* TBranchElement */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__TreeLN_TBranchElement));
   G__memfunc_setup("TBranchElement",1388,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__TreeLN_TBranchElement), -1, 0, 1, 1, 4, 0, "u 'TBranchElement' - 11 - -", "not implemented", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__TreeLN_TBranchElement), -1, 1, 1, 1, 4, 0, "u 'TBranchElement' - 11 - -", "not implemented", (void*) NULL, 0);
   G__memfunc_setup("SwitchContainer",1557,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 3, 4, 0, "U 'TObjArray' - 0 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("BuildTitle",1010,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 0, "C - - 10 - name", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("InitializeOffsets",1772,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("InitInfo",800,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("IsMissingCollection",1954,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 2, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetCurrentClass",1529,(G__InterfaceMethod) NULL, 85, G__get_linked_tagnum(&G__G__TreeLN_TClass), -1, 0, 0, 1, 2, 0, "", "Class referenced by transient description", (void*) NULL, 0);
   G__memfunc_setup("GetParentClass",1408,(G__InterfaceMethod) NULL, 85, G__get_linked_tagnum(&G__G__TreeLN_TClass), -1, 0, 0, 1, 2, 0, "", "Class referenced by fParentName", (void*) NULL, 0);
   G__memfunc_setup("GetInfoImp",978,(G__InterfaceMethod) NULL, 85, G__get_linked_tagnum(&G__G__TreeLN_TStreamerInfo), -1, 0, 0, 1, 2, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ReleaseObject",1304,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetBranchCount",1411,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 0, "U 'TBranchElement' - 0 - bre", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetBranchCount2",1461,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 0, "U 'TBranchElement' - 0 - bre", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Unroll",636,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 7, 1, 2, 0, 
"C - - 10 - name U 'TClass' - 0 - cltop "
"U 'TClass' - 0 - cl C - - 0 - ptr "
"i - 'Int_t' 0 - basketsize i - 'Int_t' 0 - splitlevel "
"i - 'Int_t' 0 - btype", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ValidateAddress",1520,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Init",404,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 9, 1, 2, 0, 
"U 'TTree' - 0 - tree U 'TBranch' - 0 - parent "
"C - - 10 - name U 'TStreamerInfo' - 0 - sinfo "
"i - 'Int_t' 0 - id C - - 0 - pointer "
"i - 'Int_t' 0 '32000' basketsize i - 'Int_t' 0 '0' splitlevel "
"i - 'Int_t' 0 '0' btype", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Init",404,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 7, 1, 2, 0, 
"U 'TTree' - 0 - tree U 'TBranch' - 0 - parent "
"C - - 10 - name U 'TClonesArray' - 0 - clones "
"i - 'Int_t' 0 '32000' basketsize i - 'Int_t' 0 '0' splitlevel "
"i - 'Int_t' 0 '-1' compress", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Init",404,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 7, 1, 2, 0, 
"U 'TTree' - 0 - tree U 'TBranch' - 0 - parent "
"C - - 10 - name U 'TVirtualCollectionProxy' - 0 - cont "
"i - 'Int_t' 0 '32000' basketsize i - 'Int_t' 0 '0' splitlevel "
"i - 'Int_t' 0 '-1' compress", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ReadLeavesImpl",1390,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ReadLeavesMakeClass",1872,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ReadLeavesCollection",2024,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ReadLeavesCollectionSplitPtrMember",3458,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ReadLeavesCollectionSplitVectorPtrMember",4085,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ReadLeavesCollectionMember",2624,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ReadLeavesClones",1600,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ReadLeavesClonesMember",2200,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ReadLeavesCustomStreamer",2458,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ReadLeavesMember",1588,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ReadLeavesMemberBranchCount",2699,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ReadLeavesMemberCounter",2324,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetReadLeavesPtr",1598,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetReadActionSequence",2111,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TBranchElement",1388,G__G__Tree_135_0_33, 105, G__get_linked_tagnum(&G__G__TreeLN_TBranchElement), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TBranchElement",1388,G__G__Tree_135_0_34, 105, G__get_linked_tagnum(&G__G__TreeLN_TBranchElement), -1, 0, 8, 1, 1, 0, 
"U 'TTree' - 0 - tree C - - 10 - name "
"U 'TStreamerInfo' - 0 - sinfo i - 'Int_t' 0 - id "
"C - - 0 - pointer i - 'Int_t' 0 '32000' basketsize "
"i - 'Int_t' 0 '0' splitlevel i - 'Int_t' 0 '0' btype", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TBranchElement",1388,G__G__Tree_135_0_35, 105, G__get_linked_tagnum(&G__G__TreeLN_TBranchElement), -1, 0, 6, 1, 1, 0, 
"U 'TTree' - 0 - tree C - - 10 - name "
"U 'TClonesArray' - 0 - clones i - 'Int_t' 0 '32000' basketsize "
"i - 'Int_t' 0 '0' splitlevel i - 'Int_t' 0 '-1' compress", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TBranchElement",1388,G__G__Tree_135_0_36, 105, G__get_linked_tagnum(&G__G__TreeLN_TBranchElement), -1, 0, 6, 1, 1, 0, 
"U 'TTree' - 0 - tree C - - 10 - name "
"U 'TVirtualCollectionProxy' - 0 - cont i - 'Int_t' 0 '32000' basketsize "
"i - 'Int_t' 0 '0' splitlevel i - 'Int_t' 0 '-1' compress", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TBranchElement",1388,G__G__Tree_135_0_37, 105, G__get_linked_tagnum(&G__G__TreeLN_TBranchElement), -1, 0, 8, 1, 1, 0, 
"U 'TBranch' - 0 - parent C - - 10 - name "
"U 'TStreamerInfo' - 0 - sinfo i - 'Int_t' 0 - id "
"C - - 0 - pointer i - 'Int_t' 0 '32000' basketsize "
"i - 'Int_t' 0 '0' splitlevel i - 'Int_t' 0 '0' btype", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TBranchElement",1388,G__G__Tree_135_0_38, 105, G__get_linked_tagnum(&G__G__TreeLN_TBranchElement), -1, 0, 6, 1, 1, 0, 
"U 'TBranch' - 0 - parent C - - 10 - name "
"U 'TClonesArray' - 0 - clones i - 'Int_t' 0 '32000' basketsize "
"i - 'Int_t' 0 '0' splitlevel i - 'Int_t' 0 '-1' compress", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TBranchElement",1388,G__G__Tree_135_0_39, 105, G__get_linked_tagnum(&G__G__TreeLN_TBranchElement), -1, 0, 6, 1, 1, 0, 
"U 'TBranch' - 0 - parent C - - 10 - name "
"U 'TVirtualCollectionProxy' - 0 - cont i - 'Int_t' 0 '32000' basketsize "
"i - 'Int_t' 0 '0' splitlevel i - 'Int_t' 0 '-1' compress", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Browse",626,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TBrowser' - 0 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Fill",391,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("FillLeaves",999,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("FindBranch",975,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__TreeLN_TBranch), -1, 0, 1, 1, 1, 0, "C - - 10 - name", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("FindLeaf",761,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__TreeLN_TLeaf), -1, 0, 1, 1, 1, 0, "C - - 10 - name", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetAddress",998,(G__InterfaceMethod) NULL,67, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetBranchCount",1399,G__G__Tree_135_0_46, 85, G__get_linked_tagnum(&G__G__TreeLN_TBranchElement), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetBranchCount2",1449,G__G__Tree_135_0_47, 85, G__get_linked_tagnum(&G__G__TreeLN_TBranchElement), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetBranchOffset",1493,G__G__Tree_135_0_48, 73, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetCheckSum",1075,G__G__Tree_135_0_49, 104, -1, G__defined_typename("UInt_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetClassName",1175,(G__InterfaceMethod) NULL,67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetClass",790,G__G__Tree_135_0_51, 85, G__get_linked_tagnum(&G__G__TreeLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetClonesName",1285,G__G__Tree_135_0_52, 67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetCollectionProxy",1870,G__G__Tree_135_0_53, 85, G__get_linked_tagnum(&G__G__TreeLN_TVirtualCollectionProxy), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetEntry",818,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 0, 
"n - 'Long64_t' 0 '0' entry i - 'Int_t' 0 '0' getall", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetExpectedType",1524,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 0, 
"U 'TClass' - 1 - clptr i 'EDataType' - 1 - type", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetIconName",1066,(G__InterfaceMethod) NULL,67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetID",429,G__G__Tree_135_0_57, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetInfo",684,G__G__Tree_135_0_58, 85, G__get_linked_tagnum(&G__G__TreeLN_TStreamerInfo), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMakeClass",1172,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetObject",887,G__G__Tree_135_0_60, 67, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetParentName",1291,G__G__Tree_135_0_61, 67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetMaximum",1022,G__G__Tree_135_0_62, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetNdata",776,G__G__Tree_135_0_63, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetType",706,G__G__Tree_135_0_64, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetStreamerType",1541,G__G__Tree_135_0_65, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetTargetClass",1405,G__G__Tree_135_0_66, 85, G__get_linked_tagnum(&G__G__TreeLN_TClass), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetTypeName",1091,G__G__Tree_135_0_67, 67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetValue",797,G__G__Tree_135_0_68, 100, -1, G__defined_typename("Double_t"), 0, 3, 1, 1, 8, 
"i - 'Int_t' 0 - i i - 'Int_t' 0 - len "
"g - 'Bool_t' 0 'kFALSE' subarr", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetValuePointer",1534,G__G__Tree_135_0_69, 89, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetClassVersion",1532,G__G__Tree_135_0_70, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsBranchFolder",1382,G__G__Tree_135_0_71, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsFolder",792,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("IsObjectOwner",1310,G__G__Tree_135_0_73, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Notify",633,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Print",525,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("PrintValue",1034,G__G__Tree_135_0_76, 121, -1, -1, 0, 1, 1, 1, 8, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Reset",515,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ResetAddress",1225,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ResetDeleteObject",1709,G__G__Tree_135_0_79, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetAddress",1010,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "Y - - 0 - addobj", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetMakeClass",1184,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kTRUE' decomposeObj", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetObject",899,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "Y - - 0 - objadd", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetBasketSize",1313,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - buffsize", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetBranchFolder",1494,G__G__Tree_135_0_84, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetClassName",1187,G__G__Tree_135_0_85, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - name", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetOffset",915,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - offset", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetParentClass",1420,G__G__Tree_135_0_87, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TClass' - 0 - clparent", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetParentName",1303,G__G__Tree_135_0_88, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - name", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetTargetClass",1417,G__G__Tree_135_0_89, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - name", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetupAddresses",1455,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetType",718,G__G__Tree_135_0_91, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - btype", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("UpdateFile",995,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Tree_135_0_93, 85, G__get_linked_tagnum(&G__G__TreeLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TBranchElement::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Tree_135_0_94, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TBranchElement::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Tree_135_0_95, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TBranchElement::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Tree_135_0_96, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TBranchElement::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__TreeLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (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__G__Tree_135_0_100, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Tree_135_0_101, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TBranchElement::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Tree_135_0_102, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TBranchElement::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Tree_135_0_103, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TBranchElement::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Tree_135_0_104, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TBranchElement::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TBranchElement", 1514, G__G__Tree_135_0_105, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTVirtualBranchBrowsable(void) {
   /* TVirtualBranchBrowsable */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__TreeLN_TVirtualBranchBrowsable));
   G__memfunc_setup("Browse",626,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TBrowser' - 0 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetIconName",1066,(G__InterfaceMethod) NULL,67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetScope",794,G__G__Tree_136_0_3, 121, -1, -1, 0, 1, 1, 1, 8, "u 'TString' - 1 - scope", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsFolder",792,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("FillListOfBrowsables",2028,G__G__Tree_136_0_5, 105, -1, G__defined_typename("Int_t"), 0, 3, 3, 1, 0, 
"u 'TList' - 1 - list U 'TBranch' - 10 - branch "
"U 'TVirtualBranchBrowsable' - 10 '0' parent", (char*)NULL, (void*) G__func2void( (Int_t (*)(TList&, const TBranch*, const TVirtualBranchBrowsable*))(&TVirtualBranchBrowsable::FillListOfBrowsables) ), 0);
   G__memfunc_setup("GetBranch",878,G__G__Tree_136_0_6, 85, G__get_linked_tagnum(&G__G__TreeLN_TBranch), -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetParent",906,G__G__Tree_136_0_7, 85, G__get_linked_tagnum(&G__G__TreeLN_TVirtualBranchBrowsable), -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetClassType",1208,G__G__Tree_136_0_8, 85, G__get_linked_tagnum(&G__G__TreeLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TypeIsPointer",1343,G__G__Tree_136_0_9, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetLeaves",896,G__G__Tree_136_0_10, 85, G__get_linked_tagnum(&G__G__TreeLN_TList), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TVirtualBranchBrowsable",2346,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__TreeLN_TVirtualBranchBrowsable), -1, 0, 4, 1, 2, 0, 
"U 'TBranch' - 10 - b U 'TClass' - 0 - type "
"g - 'Bool_t' 0 - typeIsPointer U 'TVirtualBranchBrowsable' - 10 '0' parent", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetCollectionContainedType",2659,(G__InterfaceMethod) NULL, 85, G__get_linked_tagnum(&G__G__TreeLN_TClass), -1, 0, 3, 3, 2, 0, 
"U 'TBranch' - 10 - b U 'TVirtualBranchBrowsable' - 10 - parent "
"U 'TClass' - 1 - contained", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetRegisteredGenerators",2376,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__TreeLN_listlEvoidmUcOallocatorlEvoidmUgRsPgR), G__defined_typename("list<MethodCreateListOfBrowsables_t>"), 1, 0, 3, 2, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("RegisterGenerator",1772,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 3, 2, 0, "Y - 'TVirtualBranchBrowsable::MethodCreateListOfBrowsables_t' 0 - generator", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("UnregisterGenerator",1999,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 3, 2, 0, "Y - 'TVirtualBranchBrowsable::MethodCreateListOfBrowsables_t' 0 - generator", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetType",718,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 0, "U 'TClass' - 0 - type", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetTypeIsPointer",1643,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 0, "g - 'Bool_t' 0 'kTRUE' set", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("RegisterDefaultGenerators",2596,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 3, 4, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Tree_136_0_19, 85, G__get_linked_tagnum(&G__G__TreeLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TVirtualBranchBrowsable::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Tree_136_0_20, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TVirtualBranchBrowsable::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Tree_136_0_21, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TVirtualBranchBrowsable::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Tree_136_0_22, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TVirtualBranchBrowsable::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__TreeLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (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__G__Tree_136_0_26, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Tree_136_0_27, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TVirtualBranchBrowsable::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Tree_136_0_28, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TVirtualBranchBrowsable::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Tree_136_0_29, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TVirtualBranchBrowsable::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Tree_136_0_30, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TVirtualBranchBrowsable::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("TVirtualBranchBrowsable", 2346, G__G__Tree_136_0_31, (int) ('i'), 
G__get_linked_tagnum(&G__G__TreeLN_TVirtualBranchBrowsable), -1, 0, 1, 1, 1, 0, "u 'TVirtualBranchBrowsable' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~TVirtualBranchBrowsable", 2472, G__G__Tree_136_0_32, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTMethodBrowsable(void) {
   /* TMethodBrowsable */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__TreeLN_TMethodBrowsable));
   G__memfunc_setup("GetBrowsables",1332,G__G__Tree_141_0_1, 105, -1, G__defined_typename("Int_t"), 0, 3, 3, 1, 0, 
"u 'TList' - 1 - list U 'TBranch' - 10 - branch "
"U 'TVirtualBranchBrowsable' - 10 '0' parent", (char*)NULL, (void*) G__func2void( (Int_t (*)(TList&, const TBranch*, const TVirtualBranchBrowsable*))(&TMethodBrowsable::GetBrowsables) ), 0);
   G__memfunc_setup("GetIconName",1066,(G__InterfaceMethod) NULL,67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("IsMethodBrowsable",1726,G__G__Tree_141_0_3, 103, -1, G__defined_typename("Bool_t"), 0, 1, 3, 1, 0, "U 'TMethod' - 10 - m", (char*)NULL, (void*) G__func2void( (Bool_t (*)(const TMethod*))(&TMethodBrowsable::IsMethodBrowsable) ), 0);
   G__memfunc_setup("Register",837,G__G__Tree_141_0_4, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TMethodBrowsable::Register) ), 0);
   G__memfunc_setup("Unregister",1064,G__G__Tree_141_0_5, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TMethodBrowsable::Unregister) ), 0);
   G__memfunc_setup("GetBrowsableMethodsForClass",2738,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 2, 3, 2, 0, 
"U 'TClass' - 0 - cl u 'TList' - 1 - list", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TMethodBrowsable",1622,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__TreeLN_TMethodBrowsable), -1, 0, 3, 1, 2, 0, 
"U 'TBranch' - 10 - branch U 'TMethod' - 0 - m "
"U 'TVirtualBranchBrowsable' - 10 '0' parent", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Tree_141_0_8, 85, G__get_linked_tagnum(&G__G__TreeLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TMethodBrowsable::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Tree_141_0_9, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMethodBrowsable::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Tree_141_0_10, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TMethodBrowsable::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Tree_141_0_11, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TMethodBrowsable::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__TreeLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (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__G__Tree_141_0_15, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Tree_141_0_16, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMethodBrowsable::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Tree_141_0_17, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMethodBrowsable::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Tree_141_0_18, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMethodBrowsable::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Tree_141_0_19, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMethodBrowsable::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("TMethodBrowsable", 1622, G__G__Tree_141_0_20, (int) ('i'), G__get_linked_tagnum(&G__G__TreeLN_TMethodBrowsable), -1, 0, 1, 1, 1, 0, "u 'TMethodBrowsable' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~TMethodBrowsable", 1748, G__G__Tree_141_0_21, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTNonSplitBrowsable(void) {
   /* TNonSplitBrowsable */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__TreeLN_TNonSplitBrowsable));
   G__memfunc_setup("GetBrowsables",1332,G__G__Tree_142_0_1, 105, -1, G__defined_typename("Int_t"), 0, 3, 3, 1, 0, 
"u 'TList' - 1 - list U 'TBranch' - 10 - branch "
"U 'TVirtualBranchBrowsable' - 10 '0' parent", (char*)NULL, (void*) G__func2void( (Int_t (*)(TList&, const TBranch*, const TVirtualBranchBrowsable*))(&TNonSplitBrowsable::GetBrowsables) ), 0);
   G__memfunc_setup("Register",837,G__G__Tree_142_0_2, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TNonSplitBrowsable::Register) ), 0);
   G__memfunc_setup("Unregister",1064,G__G__Tree_142_0_3, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TNonSplitBrowsable::Unregister) ), 0);
   G__memfunc_setup("TNonSplitBrowsable",1836,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__TreeLN_TNonSplitBrowsable), -1, 0, 3, 1, 2, 0, 
"U 'TStreamerElement' - 10 - element U 'TBranch' - 10 - branch "
"U 'TVirtualBranchBrowsable' - 10 '0' parent", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Tree_142_0_5, 85, G__get_linked_tagnum(&G__G__TreeLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TNonSplitBrowsable::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Tree_142_0_6, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TNonSplitBrowsable::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Tree_142_0_7, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TNonSplitBrowsable::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Tree_142_0_8, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TNonSplitBrowsable::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__TreeLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (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__G__Tree_142_0_12, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Tree_142_0_13, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TNonSplitBrowsable::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Tree_142_0_14, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TNonSplitBrowsable::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Tree_142_0_15, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TNonSplitBrowsable::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Tree_142_0_16, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TNonSplitBrowsable::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("TNonSplitBrowsable", 1836, G__G__Tree_142_0_17, (int) ('i'), G__get_linked_tagnum(&G__G__TreeLN_TNonSplitBrowsable), -1, 0, 1, 1, 1, 0, "u 'TNonSplitBrowsable' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~TNonSplitBrowsable", 1962, G__G__Tree_142_0_18, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTCollectionPropertyBrowsable(void) {
   /* TCollectionPropertyBrowsable */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__TreeLN_TCollectionPropertyBrowsable));
   G__memfunc_setup("Browse",626,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TBrowser' - 0 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetBrowsables",1332,G__G__Tree_143_0_2, 105, -1, G__defined_typename("Int_t"), 0, 3, 3, 1, 0, 
"u 'TList' - 1 - list U 'TBranch' - 10 - branch "
"U 'TVirtualBranchBrowsable' - 10 '0' parent", (char*)NULL, (void*) G__func2void( (Int_t (*)(TList&, const TBranch*, const TVirtualBranchBrowsable*))(&TCollectionPropertyBrowsable::GetBrowsables) ), 0);
   G__memfunc_setup("GetDraw",686,G__G__Tree_143_0_3, 67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Register",837,G__G__Tree_143_0_4, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TCollectionPropertyBrowsable::Register) ), 0);
   G__memfunc_setup("Unregister",1064,G__G__Tree_143_0_5, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TCollectionPropertyBrowsable::Unregister) ), 0);
   G__memfunc_setup("TCollectionPropertyBrowsable",2918,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__TreeLN_TCollectionPropertyBrowsable), -1, 0, 5, 1, 2, 0, 
"C - - 10 - name C - - 10 - title "
"C - - 10 - draw U 'TBranch' - 10 - branch "
"U 'TVirtualBranchBrowsable' - 10 '0' parent", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Tree_143_0_7, 85, G__get_linked_tagnum(&G__G__TreeLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TCollectionPropertyBrowsable::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Tree_143_0_8, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TCollectionPropertyBrowsable::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Tree_143_0_9, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TCollectionPropertyBrowsable::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Tree_143_0_10, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TCollectionPropertyBrowsable::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__TreeLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (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__G__Tree_143_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__G__Tree_143_0_15, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TCollectionPropertyBrowsable::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Tree_143_0_16, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TCollectionPropertyBrowsable::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Tree_143_0_17, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TCollectionPropertyBrowsable::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Tree_143_0_18, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TCollectionPropertyBrowsable::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("TCollectionPropertyBrowsable", 2918, G__G__Tree_143_0_19, (int) ('i'), 
G__get_linked_tagnum(&G__G__TreeLN_TCollectionPropertyBrowsable), -1, 0, 1, 1, 1, 0, "u 'TCollectionPropertyBrowsable' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~TCollectionPropertyBrowsable", 3044, G__G__Tree_143_0_20, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTCollectionMethodBrowsable(void) {
   /* TCollectionMethodBrowsable */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__TreeLN_TCollectionMethodBrowsable));
   G__memfunc_setup("GetBrowsables",1332,G__G__Tree_144_0_1, 105, -1, G__defined_typename("Int_t"), 0, 3, 3, 1, 0, 
"u 'TList' - 1 - list U 'TBranch' - 10 - branch "
"U 'TVirtualBranchBrowsable' - 10 '0' parent", (char*)NULL, (void*) G__func2void( (Int_t (*)(TList&, const TBranch*, const TVirtualBranchBrowsable*))(&TCollectionMethodBrowsable::GetBrowsables) ), 0);
   G__memfunc_setup("Register",837,G__G__Tree_144_0_2, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TCollectionMethodBrowsable::Register) ), 0);
   G__memfunc_setup("Unregister",1064,G__G__Tree_144_0_3, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TCollectionMethodBrowsable::Unregister) ), 0);
   G__memfunc_setup("TCollectionMethodBrowsable",2658,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__TreeLN_TCollectionMethodBrowsable), -1, 0, 3, 1, 2, 0, 
"U 'TBranch' - 10 - branch U 'TMethod' - 0 - m "
"U 'TVirtualBranchBrowsable' - 10 '0' parent", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Tree_144_0_5, 85, G__get_linked_tagnum(&G__G__TreeLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TCollectionMethodBrowsable::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Tree_144_0_6, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TCollectionMethodBrowsable::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Tree_144_0_7, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TCollectionMethodBrowsable::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Tree_144_0_8, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TCollectionMethodBrowsable::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__TreeLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (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__G__Tree_144_0_12, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Tree_144_0_13, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TCollectionMethodBrowsable::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Tree_144_0_14, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TCollectionMethodBrowsable::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Tree_144_0_15, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TCollectionMethodBrowsable::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Tree_144_0_16, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TCollectionMethodBrowsable::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("TCollectionMethodBrowsable", 2658, G__G__Tree_144_0_17, (int) ('i'), 
G__get_linked_tagnum(&G__G__TreeLN_TCollectionMethodBrowsable), -1, 0, 1, 1, 1, 0, "u 'TCollectionMethodBrowsable' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~TCollectionMethodBrowsable", 2784, G__G__Tree_144_0_18, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTLeaf(void) {
   /* TLeaf */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__TreeLN_TLeaf));
   G__memfunc_setup("TLeaf",460,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__TreeLN_TLeaf), -1, 0, 1, 1, 2, 0, "u 'TLeaf' - 11 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__TreeLN_TLeaf), -1, 1, 1, 1, 2, 0, "u 'TLeaf' - 11 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TLeaf",460,G__G__Tree_152_0_3, 105, G__get_linked_tagnum(&G__G__TreeLN_TLeaf), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TLeaf",460,G__G__Tree_152_0_4, 105, G__get_linked_tagnum(&G__G__TreeLN_TLeaf), -1, 0, 3, 1, 1, 0, 
"U 'TBranch' - 0 - parent C - - 10 - name "
"C - - 10 - type", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Browse",626,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TBrowser' - 0 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Export",642,G__G__Tree_152_0_6, 121, -1, -1, 0, 2, 1, 1, 0, 
"U 'TClonesArray' - 0 - - i - 'Int_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("FillBasket",993,G__G__Tree_152_0_7, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetBranch",878,G__G__Tree_152_0_8, 85, G__get_linked_tagnum(&G__G__TreeLN_TBranch), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetLeafCount",1185,G__G__Tree_152_0_9, 85, G__get_linked_tagnum(&G__G__TreeLN_TLeaf), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetLeafCounter",1400,G__G__Tree_152_0_10, 85, G__get_linked_tagnum(&G__G__TreeLN_TLeaf), -1, 0, 1, 1, 1, 8, "i - 'Int_t' 1 - countval", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetLen",575,G__G__Tree_152_0_11, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetLenStatic",1191,G__G__Tree_152_0_12, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetLenType",993,G__G__Tree_152_0_13, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetMaximum",1022,G__G__Tree_152_0_14, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetMinimum",1020,G__G__Tree_152_0_15, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetNdata",776,G__G__Tree_152_0_16, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetOffset",903,G__G__Tree_152_0_17, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetValuePointer",1534,G__G__Tree_152_0_18, 89, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetTypeName",1091,G__G__Tree_152_0_19, 67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetValue",797,G__G__Tree_152_0_20, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 0 '0' i", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Import",635,G__G__Tree_152_0_21, 121, -1, -1, 0, 2, 1, 1, 0, 
"U 'TClonesArray' - 0 - - i - 'Int_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("IsOnTerminalBranch",1795,G__G__Tree_152_0_22, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("IsRange",681,G__G__Tree_152_0_23, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("IsUnsigned",1017,G__G__Tree_152_0_24, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("PrintValue",1034,G__G__Tree_152_0_25, 121, -1, -1, 0, 1, 1, 1, 8, "i - 'Int_t' 0 '0' i", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ReadBasket",982,G__G__Tree_152_0_26, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ReadBasketExport",1624,G__G__Tree_152_0_27, 121, -1, -1, 0, 3, 1, 1, 0, 
"u 'TBuffer' - 1 - - U 'TClonesArray' - 0 - - "
"i - 'Int_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ReadValue",889,G__G__Tree_152_0_28, 121, -1, -1, 0, 1, 1, 1, 0, "u 'basic_istream<char,char_traits<char> >' 'istream' 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ResetAddress",1225,G__G__Tree_152_0_29, 105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 0, 
"Y - - 0 - add g - 'Bool_t' 0 'kFALSE' destructor", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetAddress",1010,G__G__Tree_152_0_30, 121, -1, -1, 0, 1, 1, 1, 0, "Y - - 0 '0' add", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetBranch",890,G__G__Tree_152_0_31, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TBranch' - 0 - branch", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetLeafCount",1197,G__G__Tree_152_0_32, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TLeaf' - 0 - leaf", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetLen",587,G__G__Tree_152_0_33, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 '1' len", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetOffset",915,G__G__Tree_152_0_34, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 '0' offset", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetRange",793,G__G__Tree_152_0_35, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kTRUE' range", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetUnsigned",1129,G__G__Tree_152_0_36, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Tree_152_0_37, 85, G__get_linked_tagnum(&G__G__TreeLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TLeaf::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Tree_152_0_38, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TLeaf::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Tree_152_0_39, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TLeaf::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Tree_152_0_40, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TLeaf::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__TreeLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (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__G__Tree_152_0_44, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Tree_152_0_45, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TLeaf::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Tree_152_0_46, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TLeaf::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Tree_152_0_47, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TLeaf::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Tree_152_0_48, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TLeaf::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TLeaf", 586, G__G__Tree_152_0_49, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTTreeCloner(void) {
   /* TTreeCloner */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__TreeLN_TTreeCloner));
   G__memfunc_setup("TTreeCloner",1095,G__G__Tree_154_0_1, 105, G__get_linked_tagnum(&G__G__TreeLN_TTreeCloner), -1, 0, 4, 1, 1, 0, 
"U 'TTree' - 0 - from U 'TTree' - 0 - to "
"C - 'Option_t' 10 - method h - 'UInt_t' 0 'kNone' options", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CloseOutWriteBaskets",2054,G__G__Tree_154_0_2, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CollectBranches",1516,G__G__Tree_154_0_3, 104, -1, G__defined_typename("UInt_t"), 0, 2, 1, 1, 0, 
"U 'TBranch' - 0 - from U 'TBranch' - 0 - to", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CollectBranches",1516,G__G__Tree_154_0_4, 104, -1, G__defined_typename("UInt_t"), 0, 2, 1, 1, 0, 
"U 'TObjArray' - 0 - from U 'TObjArray' - 0 - to", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CollectBranches",1516,G__G__Tree_154_0_5, 104, -1, G__defined_typename("UInt_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CollectBaskets",1427,G__G__Tree_154_0_6, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CopyMemoryBaskets",1761,G__G__Tree_154_0_7, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CopyStreamerInfos",1757,G__G__Tree_154_0_8, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CopyProcessIds",1434,G__G__Tree_154_0_9, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetWarning",1014,G__G__Tree_154_0_10, 67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Exec",389,G__G__Tree_154_0_11, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsValid",684,G__G__Tree_154_0_12, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("NeedConversion",1442,G__G__Tree_154_0_13, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SortBaskets",1141,G__G__Tree_154_0_14, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("WriteBaskets",1240,G__G__Tree_154_0_15, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Tree_154_0_16, 85, G__get_linked_tagnum(&G__G__TreeLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TTreeCloner::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Tree_154_0_17, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TTreeCloner::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Tree_154_0_18, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TTreeCloner::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Tree_154_0_19, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TTreeCloner::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,G__G__Tree_154_0_20, 85, G__get_linked_tagnum(&G__G__TreeLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,G__G__Tree_154_0_21, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,G__G__Tree_154_0_22, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Tree_154_0_23, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Tree_154_0_24, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TTreeCloner::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Tree_154_0_25, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TTreeCloner::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Tree_154_0_26, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TTreeCloner::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Tree_154_0_27, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TTreeCloner::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TTreeCloner", 1221, G__G__Tree_154_0_28, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTBranchClones(void) {
   /* TBranchClones */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__TreeLN_TBranchClones));
   G__memfunc_setup("Init",404,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 7, 1, 2, 0, 
"U 'TTree' - 0 - tree U 'TBranch' - 0 - parent "
"C - - 10 - name Y - - 0 - clonesaddress "
"i - 'Int_t' 0 '32000' basketsize i - 'Int_t' 0 '-1' compress "
"i - 'Int_t' 0 '1' splitlevel", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TBranchClones",1286,G__G__Tree_155_0_2, 105, G__get_linked_tagnum(&G__G__TreeLN_TBranchClones), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TBranchClones",1286,G__G__Tree_155_0_3, 105, G__get_linked_tagnum(&G__G__TreeLN_TBranchClones), -1, 0, 6, 1, 1, 0, 
"U 'TTree' - 0 - tree C - - 10 - name "
"Y - - 0 - clonesaddress i - 'Int_t' 0 '32000' basketsize "
"i - 'Int_t' 0 '-1' compress i - 'Int_t' 0 '1' splitlevel", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TBranchClones",1286,G__G__Tree_155_0_4, 105, G__get_linked_tagnum(&G__G__TreeLN_TBranchClones), -1, 0, 6, 1, 1, 0, 
"U 'TBranch' - 0 - parent C - - 10 - name "
"Y - - 0 - clonesaddress i - 'Int_t' 0 '32000' basketsize "
"i - 'Int_t' 0 '-1' compress i - 'Int_t' 0 '1' splitlevel", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Browse",626,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TBrowser' - 0 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Fill",391,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetEntry",818,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 0, 
"n - 'Long64_t' 0 '0' entry i - 'Int_t' 0 '0' getall", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetN",366,G__G__Tree_155_0_8, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetList",700,G__G__Tree_155_0_9, 85, G__get_linked_tagnum(&G__G__TreeLN_TClonesArray), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsFolder",792,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Print",525,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Reset",515,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetAddress",1010,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "Y - - 0 - add", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetBasketSize",1313,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - buffsize", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("UpdateFile",995,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Tree_155_0_16, 85, G__get_linked_tagnum(&G__G__TreeLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TBranchClones::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Tree_155_0_17, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TBranchClones::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Tree_155_0_18, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TBranchClones::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Tree_155_0_19, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TBranchClones::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__TreeLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (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__G__Tree_155_0_23, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Tree_155_0_24, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TBranchClones::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Tree_155_0_25, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TBranchClones::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Tree_155_0_26, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TBranchClones::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Tree_155_0_27, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TBranchClones::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TBranchClones", 1412, G__G__Tree_155_0_28, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTSelector(void) {
   /* TSelector */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__TreeLN_TSelector));
   G__memfunc_setup("TSelector",917,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__TreeLN_TSelector), -1, 0, 1, 1, 4, 0, "u 'TSelector' - 11 - -", "not implemented", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__TreeLN_TSelector), -1, 1, 1, 1, 4, 0, "u 'TSelector' - 11 - -", "not implemented", (void*) NULL, 0);
   G__memfunc_setup("TSelector",917,G__G__Tree_191_0_3, 105, G__get_linked_tagnum(&G__G__TreeLN_TSelector), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Version",742,G__G__Tree_191_0_4, 105, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Init",404,G__G__Tree_191_0_5, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TTree' - 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Begin",485,G__G__Tree_191_0_6, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TTree' - 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SlaveBegin",992,G__G__Tree_191_0_7, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TTree' - 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Notify",633,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetOption",921,G__G__Tree_191_0_9, 67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetStatus",932,G__G__Tree_191_0_10, 110, -1, G__defined_typename("Long64_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetEntry",818,G__G__Tree_191_0_11, 105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 0, 
"n - 'Long64_t' 0 - - i - 'Int_t' 0 '0' -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ProcessCut",1035,G__G__Tree_191_0_12, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "n - 'Long64_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ProcessFill",1126,G__G__Tree_191_0_13, 121, -1, -1, 0, 1, 1, 1, 0, "n - 'Long64_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Process",735,G__G__Tree_191_0_14, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "n - 'Long64_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetOption",933,G__G__Tree_191_0_15, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetObject",899,G__G__Tree_191_0_16, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TObject' - 0 - obj", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetInputList",1240,G__G__Tree_191_0_17, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TList' - 0 - input", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetStatus",944,G__G__Tree_191_0_18, 121, -1, -1, 0, 1, 1, 1, 0, "n - 'Long64_t' 0 - status", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetOutputList",1357,G__G__Tree_191_0_19, 85, G__get_linked_tagnum(&G__G__TreeLN_TList), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SlaveTerminate",1444,G__G__Tree_191_0_20, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Terminate",937,G__G__Tree_191_0_21, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Abort",504,G__G__Tree_191_0_22, 121, -1, -1, 0, 2, 1, 1, 0, 
"C - - 10 - why i 'TSelector::EAbort' - 0 'kAbortProcess' what", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetAbort",792,G__G__Tree_191_0_23, 105, G__get_linked_tagnum(&G__G__TreeLN_TSelectorcLcLEAbort), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetSelector",1121,G__G__Tree_191_0_24, 85, G__get_linked_tagnum(&G__G__TreeLN_TSelector), -1, 0, 1, 3, 1, 0, "C - - 10 - filename", (char*)NULL, (void*) G__func2void( (TSelector* (*)(const char*))(&TSelector::GetSelector) ), 0);
   G__memfunc_setup("IsStandardDraw",1403,G__G__Tree_191_0_25, 103, -1, G__defined_typename("Bool_t"), 0, 1, 3, 1, 0, "C - - 10 - selec", (char*)NULL, (void*) G__func2void( (Bool_t (*)(const char*))(&TSelector::IsStandardDraw) ), 0);
   G__memfunc_setup("Class",502,G__G__Tree_191_0_26, 85, G__get_linked_tagnum(&G__G__TreeLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TSelector::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Tree_191_0_27, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TSelector::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Tree_191_0_28, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TSelector::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Tree_191_0_29, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TSelector::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__TreeLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (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__G__Tree_191_0_33, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Tree_191_0_34, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TSelector::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Tree_191_0_35, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TSelector::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Tree_191_0_36, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TSelector::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Tree_191_0_37, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TSelector::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TSelector", 1043, G__G__Tree_191_0_38, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTVirtualIndex(void) {
   /* TVirtualIndex */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__TreeLN_TVirtualIndex));
   G__memfunc_setup("Append",600,G__G__Tree_193_0_2, 121, -1, -1, 0, 2, 1, 1, 0, 
"U 'TVirtualIndex' - 10 - - g - 'Bool_t' 0 'kFALSE' delaySort", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("GetEntryNumberFriend",2035,G__G__Tree_193_0_3, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "U 'TTree' - 10 - -", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("GetEntryNumberWithIndex",2351,G__G__Tree_193_0_4, 110, -1, G__defined_typename("Long64_t"), 0, 2, 1, 1, 8, 
"i - 'Int_t' 0 - major i - 'Int_t' 0 - minor", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("GetEntryNumberWithBestIndex",2749,G__G__Tree_193_0_5, 110, -1, G__defined_typename("Long64_t"), 0, 2, 1, 1, 8, 
"i - 'Int_t' 0 - major i - 'Int_t' 0 - minor", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("GetMajorName",1178,G__G__Tree_193_0_6, 67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("GetMinorName",1190,G__G__Tree_193_0_7, 67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("GetN",366,G__G__Tree_193_0_8, 110, -1, G__defined_typename("Long64_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("GetTree",688,G__G__Tree_193_0_9, 85, G__get_linked_tagnum(&G__G__TreeLN_TTree), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("UpdateFormulaLeaves",1945,G__G__Tree_193_0_10, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TTree' - 10 - parent", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("SetTree",700,G__G__Tree_193_0_11, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TTree' - 10 - T", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("Class",502,G__G__Tree_193_0_12, 85, G__get_linked_tagnum(&G__G__TreeLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TVirtualIndex::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Tree_193_0_13, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TVirtualIndex::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Tree_193_0_14, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TVirtualIndex::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Tree_193_0_15, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TVirtualIndex::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__TreeLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (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__G__Tree_193_0_19, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Tree_193_0_20, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TVirtualIndex::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Tree_193_0_21, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TVirtualIndex::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Tree_193_0_22, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TVirtualIndex::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Tree_193_0_23, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TVirtualIndex::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TVirtualIndex", 1457, G__G__Tree_193_0_24, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__G__Tree_193_0_25, (int) ('u'), G__get_linked_tagnum(&G__G__TreeLN_TVirtualIndex), -1, 1, 1, 1, 1, 0, "u 'TVirtualIndex' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTVirtualTreePlayer(void) {
   /* TVirtualTreePlayer */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__TreeLN_TVirtualTreePlayer));
   G__memfunc_setup("BuildIndex",1000,G__G__Tree_194_0_2, 85, G__get_linked_tagnum(&G__G__TreeLN_TVirtualIndex), -1, 0, 3, 1, 1, 0, 
"U 'TTree' - 10 - T C - - 10 - majorname "
"C - - 10 - minorname", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("CopyTree",811,G__G__Tree_194_0_3, 85, G__get_linked_tagnum(&G__G__TreeLN_TTree), -1, 0, 4, 1, 1, 0, 
"C - - 10 - selection C - 'Option_t' 10 '\"\"' option "
"n - 'Long64_t' 0 '1000000000' nentries n - 'Long64_t' 0 '0' firstentry", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("DrawScript",1027,G__G__Tree_194_0_4, 110, -1, G__defined_typename("Long64_t"), 0, 6, 1, 1, 0, 
"C - - 10 - wrapperPrefix C - - 10 - macrofilename "
"C - - 10 - cutfilename C - 'Option_t' 10 - option "
"n - 'Long64_t' 0 - nentries n - 'Long64_t' 0 - firstentry", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("DrawSelect",1006,G__G__Tree_194_0_5, 110, -1, G__defined_typename("Long64_t"), 0, 5, 1, 1, 0, 
"C - - 10 - varexp C - - 10 - selection "
"C - 'Option_t' 10 - option n - 'Long64_t' 0 - nentries "
"n - 'Long64_t' 0 - firstentry", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("Fit",291,G__G__Tree_194_0_6, 105, -1, G__defined_typename("Int_t"), 0, 7, 1, 1, 0, 
"C - - 10 - formula C - - 10 - varexp "
"C - - 10 - selection C - 'Option_t' 10 - option "
"C - 'Option_t' 10 - goption n - 'Long64_t' 0 - nentries "
"n - 'Long64_t' 0 - firstentry", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("GetDimension",1222,G__G__Tree_194_0_7, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("GetHistogram",1230,G__G__Tree_194_0_8, 85, G__get_linked_tagnum(&G__G__TreeLN_TH1), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("GetNfill",789,G__G__Tree_194_0_9, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("GetEntries",1018,G__G__Tree_194_0_10, 110, -1, G__defined_typename("Long64_t"), 0, 1, 1, 1, 0, "C - - 10 - -", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("GetSelectedRows",1524,G__G__Tree_194_0_11, 110, -1, G__defined_typename("Long64_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("GetSelect",896,G__G__Tree_194_0_12, 85, G__get_linked_tagnum(&G__G__TreeLN_TTreeFormula), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("GetVar",585,G__G__Tree_194_0_13, 85, G__get_linked_tagnum(&G__G__TreeLN_TTreeFormula), -1, 0, 1, 1, 1, 8, "i - 'Int_t' 0 - -", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("GetVar1",634,G__G__Tree_194_0_14, 85, G__get_linked_tagnum(&G__G__TreeLN_TTreeFormula), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("GetVar2",635,G__G__Tree_194_0_15, 85, G__get_linked_tagnum(&G__G__TreeLN_TTreeFormula), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("GetVar3",636,G__G__Tree_194_0_16, 85, G__get_linked_tagnum(&G__G__TreeLN_TTreeFormula), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("GetVar4",637,G__G__Tree_194_0_17, 85, G__get_linked_tagnum(&G__G__TreeLN_TTreeFormula), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("GetVal",579,G__G__Tree_194_0_18, 68, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 0 - -", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("GetV1",423,G__G__Tree_194_0_19, 68, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("GetV2",424,G__G__Tree_194_0_20, 68, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("GetV3",425,G__G__Tree_194_0_21, 68, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("GetV4",426,G__G__Tree_194_0_22, 68, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("GetW",375,G__G__Tree_194_0_23, 68, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("MakeClass",884,G__G__Tree_194_0_24, 105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 0, 
"C - - 10 - classname C - - 10 - option", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("MakeCode",761,G__G__Tree_194_0_25, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "C - - 10 - filename", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("MakeProxy",928,G__G__Tree_194_0_26, 105, -1, G__defined_typename("Int_t"), 0, 5, 1, 1, 0, 
"C - - 10 - classname C - - 10 '0' macrofilename "
"C - - 10 '0' cutfilename C - - 10 '0' option "
"i - 'Int_t' 0 '3' maxUnrolling", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("Principal",930,G__G__Tree_194_0_27, 85, G__get_linked_tagnum(&G__G__TreeLN_TPrincipal), -1, 0, 5, 1, 1, 0, 
"C - - 10 '\"\"' varexp C - - 10 '\"\"' selection "
"C - 'Option_t' 10 '\"np\"' option n - 'Long64_t' 0 '1000000000' nentries "
"n - 'Long64_t' 0 '0' firstentry", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("Process",735,G__G__Tree_194_0_28, 110, -1, G__defined_typename("Long64_t"), 0, 4, 1, 1, 0, 
"C - - 10 - filename C - 'Option_t' 10 '\"\"' option "
"n - 'Long64_t' 0 '1000000000' nentries n - 'Long64_t' 0 '0' firstentry", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("Process",735,G__G__Tree_194_0_29, 110, -1, G__defined_typename("Long64_t"), 0, 4, 1, 1, 0, 
"U 'TSelector' - 0 - selector C - 'Option_t' 10 '\"\"' option "
"n - 'Long64_t' 0 '1000000000' nentries n - 'Long64_t' 0 '0' firstentry", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("Scan",389,G__G__Tree_194_0_30, 110, -1, G__defined_typename("Long64_t"), 0, 5, 1, 1, 0, 
"C - - 10 - varexp C - - 10 - selection "
"C - 'Option_t' 10 - option n - 'Long64_t' 0 - nentries "
"n - 'Long64_t' 0 - firstentry", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("Query",534,G__G__Tree_194_0_31, 85, G__get_linked_tagnum(&G__G__TreeLN_TSQLResult), -1, 0, 5, 1, 1, 0, 
"C - - 10 - varexp C - - 10 - selection "
"C - 'Option_t' 10 - option n - 'Long64_t' 0 - nentries "
"n - 'Long64_t' 0 - firstentry", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("SetEstimate",1128,G__G__Tree_194_0_32, 121, -1, -1, 0, 1, 1, 1, 0, "n - 'Long64_t' 0 - n", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("SetTree",700,G__G__Tree_194_0_33, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TTree' - 0 - t", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("StartViewer",1152,G__G__Tree_194_0_34, 121, -1, -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - ww i - 'Int_t' 0 - wh", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("UnbinnedFit",1110,G__G__Tree_194_0_35, 105, -1, G__defined_typename("Int_t"), 0, 6, 1, 1, 0, 
"C - - 10 - formula C - - 10 - varexp "
"C - - 10 - selection C - 'Option_t' 10 - option "
"n - 'Long64_t' 0 - nentries n - 'Long64_t' 0 - firstentry", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("UpdateFormulaLeaves",1945,G__G__Tree_194_0_36, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("GetCurrentPlayer",1648,G__G__Tree_194_0_37, 85, G__get_linked_tagnum(&G__G__TreeLN_TVirtualTreePlayer), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TVirtualTreePlayer* (*)())(&TVirtualTreePlayer::GetCurrentPlayer) ), 0);
   G__memfunc_setup("TreePlayer",1021,G__G__Tree_194_0_38, 85, G__get_linked_tagnum(&G__G__TreeLN_TVirtualTreePlayer), -1, 0, 1, 3, 1, 0, "U 'TTree' - 0 - obj", (char*)NULL, (void*) G__func2void( (TVirtualTreePlayer* (*)(TTree*))(&TVirtualTreePlayer::TreePlayer) ), 0);
   G__memfunc_setup("SetPlayer",921,G__G__Tree_194_0_39, 121, -1, -1, 0, 1, 3, 1, 0, "C - - 10 - player", (char*)NULL, (void*) G__func2void( (void (*)(const char*))(&TVirtualTreePlayer::SetPlayer) ), 0);
   G__memfunc_setup("Class",502,G__G__Tree_194_0_40, 85, G__get_linked_tagnum(&G__G__TreeLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TVirtualTreePlayer::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Tree_194_0_41, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TVirtualTreePlayer::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Tree_194_0_42, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TVirtualTreePlayer::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Tree_194_0_43, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TVirtualTreePlayer::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__TreeLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (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__G__Tree_194_0_47, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Tree_194_0_48, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TVirtualTreePlayer::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Tree_194_0_49, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TVirtualTreePlayer::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Tree_194_0_50, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TVirtualTreePlayer::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Tree_194_0_51, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TVirtualTreePlayer::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TVirtualTreePlayer", 1974, G__G__Tree_194_0_52, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__G__Tree_194_0_53, (int) ('u'), G__get_linked_tagnum(&G__G__TreeLN_TVirtualTreePlayer), -1, 1, 1, 1, 1, 0, "u 'TVirtualTreePlayer' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTEventList(void) {
   /* TEventList */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__TreeLN_TEventList));
   G__memfunc_setup("TEventList",1010,G__G__Tree_196_0_1, 105, G__get_linked_tagnum(&G__G__TreeLN_TEventList), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TEventList",1010,G__G__Tree_196_0_2, 105, G__get_linked_tagnum(&G__G__TreeLN_TEventList), -1, 0, 4, 1, 1, 0, 
"C - - 10 - name C - - 10 '\"\"' title "
"i - 'Int_t' 0 '0' initsize i - 'Int_t' 0 '0' delta", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TEventList",1010,G__G__Tree_196_0_3, 105, G__get_linked_tagnum(&G__G__TreeLN_TEventList), -1, 0, 1, 1, 1, 0, "u 'TEventList' - 11 - list", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Add",265,G__G__Tree_196_0_4, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TEventList' - 10 - list", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Clear",487,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Contains",831,G__G__Tree_196_0_6, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "n - 'Long64_t' 0 - entry", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ContainsRange",1324,G__G__Tree_196_0_7, 103, -1, G__defined_typename("Bool_t"), 0, 2, 1, 1, 0, 
"n - 'Long64_t' 0 - entrymin n - 'Long64_t' 0 - entrymax", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DirectoryAutoAdd",1623,G__G__Tree_196_0_8, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TDirectory' - 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Enter",510,G__G__Tree_196_0_9, 121, -1, -1, 0, 1, 1, 1, 0, "n - 'Long64_t' 0 - entry", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetDirectory",1237,G__G__Tree_196_0_10, 85, G__get_linked_tagnum(&G__G__TreeLN_TDirectory), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetEntry",818,G__G__Tree_196_0_11, 110, -1, G__defined_typename("Long64_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 0 - index", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetIndex",792,G__G__Tree_196_0_12, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 8, "n - 'Long64_t' 0 - entry", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetList",700,G__G__Tree_196_0_13, 78, -1, G__defined_typename("Long64_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetN",366,G__G__Tree_196_0_14, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetReapplyCut",1321,G__G__Tree_196_0_15, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetSize",699,G__G__Tree_196_0_16, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Intersect",945,G__G__Tree_196_0_17, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TEventList' - 10 - list", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Merge",496,G__G__Tree_196_0_18, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "U 'TCollection' - 0 - list", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Print",525,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Reset",515,G__G__Tree_196_0_20, 121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Resize",626,G__G__Tree_196_0_21, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 '0' delta", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetDelta",790,G__G__Tree_196_0_22, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 '100' delta", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetDirectory",1249,G__G__Tree_196_0_23, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TDirectory' - 0 - dir", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetName",685,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - name", "*MENU*", (void*) NULL, 1);
   G__memfunc_setup("SetReapplyCut",1333,G__G__Tree_196_0_25, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kFALSE' apply", "*TOGGLE*", (void*) NULL, 1);
   G__memfunc_setup("Sort",424,G__G__Tree_196_0_26, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Subtract",840,G__G__Tree_196_0_27, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TEventList' - 10 - list", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("operator=",937,G__G__Tree_196_0_28, 117, G__get_linked_tagnum(&G__G__TreeLN_TEventList), -1, 1, 1, 1, 1, 0, "u 'TEventList' - 11 - list", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Tree_196_0_29, 85, G__get_linked_tagnum(&G__G__TreeLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TEventList::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Tree_196_0_30, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEventList::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Tree_196_0_31, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TEventList::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Tree_196_0_32, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TEventList::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__TreeLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (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__G__Tree_196_0_36, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Tree_196_0_37, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEventList::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Tree_196_0_38, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEventList::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Tree_196_0_39, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEventList::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Tree_196_0_40, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEventList::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TEventList", 1136, G__G__Tree_196_0_41, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTEntryList(void) {
   /* TEntryList */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__TreeLN_TEntryList));
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__TreeLN_TEntryList), -1, 1, 1, 1, 4, 0, "u 'TEntryList' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("TEntryList",1026,G__G__Tree_197_0_2, 105, G__get_linked_tagnum(&G__G__TreeLN_TEntryList), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TEntryList",1026,G__G__Tree_197_0_3, 105, G__get_linked_tagnum(&G__G__TreeLN_TEntryList), -1, 0, 2, 1, 1, 0, 
"C - - 10 - name C - - 10 - title", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TEntryList",1026,G__G__Tree_197_0_4, 105, G__get_linked_tagnum(&G__G__TreeLN_TEntryList), -1, 0, 3, 1, 1, 0, 
"C - - 10 - name C - - 10 - title "
"U 'TTree' - 10 - tree", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TEntryList",1026,G__G__Tree_197_0_5, 105, G__get_linked_tagnum(&G__G__TreeLN_TEntryList), -1, 0, 4, 1, 1, 0, 
"C - - 10 - name C - - 10 - title "
"C - - 10 - treename C - - 10 - filename", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TEntryList",1026,G__G__Tree_197_0_6, 105, G__get_linked_tagnum(&G__G__TreeLN_TEntryList), -1, 0, 1, 1, 1, 0, "U 'TTree' - 10 - tree", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TEntryList",1026,G__G__Tree_197_0_7, 105, G__get_linked_tagnum(&G__G__TreeLN_TEntryList), -1, 0, 1, 1, 1, 0, "u 'TEntryList' - 11 - elist", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Add",265,G__G__Tree_197_0_8, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TEntryList' - 10 - elist", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Contains",831,G__G__Tree_197_0_9, 105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 0, 
"n - 'Long64_t' 0 - entry U 'TTree' - 0 '0' tree", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DirectoryAutoAdd",1623,G__G__Tree_197_0_10, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TDirectory' - 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Enter",510,G__G__Tree_197_0_11, 103, -1, G__defined_typename("Bool_t"), 0, 2, 1, 1, 0, 
"n - 'Long64_t' 0 - entry U 'TTree' - 0 '0' tree", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetCurrentList",1439,G__G__Tree_197_0_12, 85, G__get_linked_tagnum(&G__G__TreeLN_TEntryList), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetEntryList",1230,G__G__Tree_197_0_13, 85, G__get_linked_tagnum(&G__G__TreeLN_TEntryList), -1, 0, 3, 1, 1, 0, 
"C - - 10 - treename C - - 10 - filename "
"C - 'Option_t' 10 '\"\"' opt", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetEntry",818,G__G__Tree_197_0_14, 110, -1, G__defined_typename("Long64_t"), 0, 1, 1, 1, 0, "i - 'Int_t' 0 - index", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetEntryAndTree",1493,G__G__Tree_197_0_15, 110, -1, G__defined_typename("Long64_t"), 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - index i - 'Int_t' 1 - treenum", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetEntriesToProcess",1948,G__G__Tree_197_0_16, 110, -1, G__defined_typename("Long64_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetLists",815,G__G__Tree_197_0_17, 85, G__get_linked_tagnum(&G__G__TreeLN_TList), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetDirectory",1237,G__G__Tree_197_0_18, 85, G__get_linked_tagnum(&G__G__TreeLN_TDirectory), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetN",366,G__G__Tree_197_0_19, 110, -1, G__defined_typename("Long64_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetTreeName",1073,G__G__Tree_197_0_20, 67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetFileName",1057,G__G__Tree_197_0_21, 67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetTreeNumber",1305,G__G__Tree_197_0_22, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetReapplyCut",1321,G__G__Tree_197_0_23, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Merge",496,G__G__Tree_197_0_24, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "U 'TCollection' - 0 - list", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Next",415,G__G__Tree_197_0_25, 110, -1, G__defined_typename("Long64_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("OptimizeStorage",1574,G__G__Tree_197_0_26, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Remove",622,G__G__Tree_197_0_27, 103, -1, G__defined_typename("Bool_t"), 0, 2, 1, 1, 0, 
"n - 'Long64_t' 0 - entry U 'TTree' - 0 '0' tree", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Reset",515,G__G__Tree_197_0_28, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Print",525,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetDirectory",1249,G__G__Tree_197_0_30, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TDirectory' - 0 - dir", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetEntriesToProcess",1960,G__G__Tree_197_0_31, 121, -1, -1, 0, 1, 1, 1, 0, "n - 'Long64_t' 0 - nen", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetShift",810,G__G__Tree_197_0_32, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - shift", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetTree",700,G__G__Tree_197_0_33, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TTree' - 10 - tree", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetTree",700,G__G__Tree_197_0_34, 121, -1, -1, 0, 2, 1, 1, 0, 
"C - - 10 - treename C - - 10 - filename", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetTreeName",1085,G__G__Tree_197_0_35, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - treename", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetFileName",1069,G__G__Tree_197_0_36, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - filename", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetTreeNumber",1317,G__G__Tree_197_0_37, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - index", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetReapplyCut",1333,G__G__Tree_197_0_38, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kFALSE' apply", "*TOGGLE*", (void*) NULL, 1);
   G__memfunc_setup("Subtract",840,G__G__Tree_197_0_39, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TEntryList' - 10 - elist", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Tree_197_0_40, 85, G__get_linked_tagnum(&G__G__TreeLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TEntryList::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Tree_197_0_41, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEntryList::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Tree_197_0_42, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TEntryList::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Tree_197_0_43, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TEntryList::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__TreeLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (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__G__Tree_197_0_47, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Tree_197_0_48, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEntryList::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Tree_197_0_49, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEntryList::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Tree_197_0_50, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEntryList::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Tree_197_0_51, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEntryList::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TEntryList", 1152, G__G__Tree_197_0_52, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTFriendElement(void) {
   /* TFriendElement */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__TreeLN_TFriendElement));
   G__memfunc_setup("TFriendElement",1398,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__TreeLN_TFriendElement), -1, 0, 1, 1, 2, 0, "u 'TFriendElement' - 11 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__TreeLN_TFriendElement), -1, 1, 1, 1, 2, 0, "u 'TFriendElement' - 11 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TFriendElement",1398,G__G__Tree_198_0_3, 105, G__get_linked_tagnum(&G__G__TreeLN_TFriendElement), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TFriendElement",1398,G__G__Tree_198_0_4, 105, G__get_linked_tagnum(&G__G__TreeLN_TFriendElement), -1, 0, 3, 1, 1, 0, 
"U 'TTree' - 0 - tree C - - 10 - treename "
"C - - 10 - filename", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TFriendElement",1398,G__G__Tree_198_0_5, 105, G__get_linked_tagnum(&G__G__TreeLN_TFriendElement), -1, 0, 3, 1, 1, 0, 
"U 'TTree' - 0 - tree C - - 10 - treename "
"U 'TFile' - 0 - file", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TFriendElement",1398,G__G__Tree_198_0_6, 105, G__get_linked_tagnum(&G__G__TreeLN_TFriendElement), -1, 0, 3, 1, 1, 0, 
"U 'TTree' - 0 - tree U 'TTree' - 0 - friendtree "
"C - - 10 - alias", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Connect",714,G__G__Tree_198_0_7, 85, G__get_linked_tagnum(&G__G__TreeLN_TTree), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DisConnect",1002,G__G__Tree_198_0_8, 85, G__get_linked_tagnum(&G__G__TreeLN_TTree), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetFile",672,G__G__Tree_198_0_9, 85, G__get_linked_tagnum(&G__G__TreeLN_TFile), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetParentTree",1306,G__G__Tree_198_0_10, 85, G__get_linked_tagnum(&G__G__TreeLN_TTree), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetTree",688,G__G__Tree_198_0_11, 85, G__get_linked_tagnum(&G__G__TreeLN_TTree), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetTreeName",1073,G__G__Tree_198_0_12, 67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ls",223,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Tree_198_0_14, 85, G__get_linked_tagnum(&G__G__TreeLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TFriendElement::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Tree_198_0_15, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TFriendElement::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Tree_198_0_16, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TFriendElement::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Tree_198_0_17, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TFriendElement::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__TreeLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (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__G__Tree_198_0_21, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Tree_198_0_22, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TFriendElement::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Tree_198_0_23, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TFriendElement::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Tree_198_0_24, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TFriendElement::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Tree_198_0_25, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TFriendElement::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TFriendElement", 1524, G__G__Tree_198_0_26, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTCut(void) {
   /* TCut */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__TreeLN_TCut));
   G__memfunc_setup("operator<",936,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 4, 0, "u 'TCut' - 11 - rhs", "Intentional left unimplemented", (void*) NULL, 0);
   G__memfunc_setup("operator<=",997,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 4, 0, "u 'TCut' - 11 - rhs", "Intentional left unimplemented", (void*) NULL, 0);
   G__memfunc_setup("operator>",938,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 4, 0, "u 'TCut' - 11 - rhs", "Intentional left unimplemented", (void*) NULL, 0);
   G__memfunc_setup("operator>=",999,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 4, 0, "u 'TCut' - 11 - rhs", "Intentional left unimplemented", (void*) NULL, 0);
   G__memfunc_setup("TCut",384,G__G__Tree_199_0_5, 105, G__get_linked_tagnum(&G__G__TreeLN_TCut), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TCut",384,G__G__Tree_199_0_6, 105, G__get_linked_tagnum(&G__G__TreeLN_TCut), -1, 0, 1, 1, 1, 0, "C - - 10 - title", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TCut",384,G__G__Tree_199_0_7, 105, G__get_linked_tagnum(&G__G__TreeLN_TCut), -1, 0, 2, 1, 1, 0, 
"C - - 10 - name C - - 10 - title", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TCut",384,G__G__Tree_199_0_8, 105, G__get_linked_tagnum(&G__G__TreeLN_TCut), -1, 0, 1, 1, 1, 0, "u 'TCut' - 11 - cut", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,G__G__Tree_199_0_9, 117, G__get_linked_tagnum(&G__G__TreeLN_TCut), -1, 1, 1, 1, 1, 0, "C - - 10 - rhs", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,G__G__Tree_199_0_10, 117, G__get_linked_tagnum(&G__G__TreeLN_TCut), -1, 1, 1, 1, 1, 0, "u 'TCut' - 11 - rhs", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator+=",980,G__G__Tree_199_0_11, 117, G__get_linked_tagnum(&G__G__TreeLN_TCut), -1, 1, 1, 1, 1, 0, "C - - 10 - rhs", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator+=",980,G__G__Tree_199_0_12, 117, G__get_linked_tagnum(&G__G__TreeLN_TCut), -1, 1, 1, 1, 1, 0, "u 'TCut' - 11 - rhs", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator*=",979,G__G__Tree_199_0_13, 117, G__get_linked_tagnum(&G__G__TreeLN_TCut), -1, 1, 1, 1, 1, 0, "C - - 10 - rhs", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator*=",979,G__G__Tree_199_0_14, 117, G__get_linked_tagnum(&G__G__TreeLN_TCut), -1, 1, 1, 1, 1, 0, "u 'TCut' - 11 - rhs", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator==",998,G__G__Tree_199_0_15, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 8, "C - - 10 - rhs", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator==",998,G__G__Tree_199_0_16, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 8, "u 'TCut' - 11 - rhs", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator!=",970,G__G__Tree_199_0_17, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 8, "C - - 10 - rhs", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator!=",970,G__G__Tree_199_0_18, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 8, "u 'TCut' - 11 - rhs", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator const char*",1947,G__G__Tree_199_0_19, 67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Tree_199_0_20, 85, G__get_linked_tagnum(&G__G__TreeLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TCut::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Tree_199_0_21, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TCut::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Tree_199_0_22, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TCut::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Tree_199_0_23, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TCut::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__TreeLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (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__G__Tree_199_0_27, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Tree_199_0_28, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TCut::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Tree_199_0_29, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TCut::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Tree_199_0_30, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TCut::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Tree_199_0_31, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TCut::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TCut", 510, G__G__Tree_199_0_32, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTBranchRef(void) {
   /* TBranchRef */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__TreeLN_TBranchRef));
   G__memfunc_setup("ReadLeavesImpl",1390,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TBranchRef",959,G__G__Tree_200_0_2, 105, G__get_linked_tagnum(&G__G__TreeLN_TBranchRef), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TBranchRef",959,G__G__Tree_200_0_3, 105, G__get_linked_tagnum(&G__G__TreeLN_TBranchRef), -1, 0, 1, 1, 1, 0, "U 'TTree' - 0 - tree", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Clear",487,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Fill",391,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("FillLeaves",999,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetRefTable",1061,G__G__Tree_200_0_7, 85, G__get_linked_tagnum(&G__G__TreeLN_TRefTable), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Notify",633,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Print",525,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Reset",515,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetParent",918,G__G__Tree_200_0_11, 105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 0, 
"U 'TObject' - 10 - obj i - 'Int_t' 0 - branchID", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetReadEntry",1210,G__G__Tree_200_0_12, 121, -1, -1, 0, 1, 1, 1, 0, "n - 'Long64_t' 0 - entry", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Tree_200_0_13, 85, G__get_linked_tagnum(&G__G__TreeLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TBranchRef::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Tree_200_0_14, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TBranchRef::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Tree_200_0_15, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TBranchRef::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Tree_200_0_16, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TBranchRef::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__TreeLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (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__G__Tree_200_0_20, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Tree_200_0_21, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TBranchRef::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Tree_200_0_22, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TBranchRef::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Tree_200_0_23, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TBranchRef::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Tree_200_0_24, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TBranchRef::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TBranchRef", 1085, G__G__Tree_200_0_25, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTTreeFriendLeafIter(void) {
   /* TTreeFriendLeafIter */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__TreeLN_TTreeFriendLeafIter));
   G__memfunc_setup("TTreeFriendLeafIter",1864,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__TreeLN_TTreeFriendLeafIter), -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TTreeFriendLeafIter",1864,G__G__Tree_206_0_2, 105, G__get_linked_tagnum(&G__G__TreeLN_TTreeFriendLeafIter), -1, 0, 2, 1, 1, 0, 
"U 'TTree' - 10 - t g - 'Bool_t' 0 'kIterForward' dir", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TTreeFriendLeafIter",1864,G__G__Tree_206_0_3, 105, G__get_linked_tagnum(&G__G__TreeLN_TTreeFriendLeafIter), -1, 0, 1, 1, 1, 0, "u 'TTreeFriendLeafIter' - 11 - iter", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL,117, G__get_linked_tagnum(&G__G__TreeLN_TIterator), -1, 1, 1, 1, 1, 0, "u 'TIterator' - 11 - rhs", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("operator=",937,G__G__Tree_206_0_5, 117, G__get_linked_tagnum(&G__G__TreeLN_TTreeFriendLeafIter), -1, 1, 1, 1, 1, 0, "u 'TTreeFriendLeafIter' - 11 - rhs", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetCollection",1324,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__TreeLN_TCollection), -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetOption",921,(G__InterfaceMethod) NULL,67, -1, G__defined_typename("Option_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Next",415,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__TreeLN_TObject), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Reset",515,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("operator!=",970,(G__InterfaceMethod) NULL,103, -1, -1, 0, 1, 1, 1, 8, "u 'TIterator' - 11 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("operator!=",970,G__G__Tree_206_0_11, 103, -1, -1, 0, 1, 1, 1, 8, "u 'TTreeFriendLeafIter' - 11 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator*",918,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__TreeLN_TObject), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Tree_206_0_13, 85, G__get_linked_tagnum(&G__G__TreeLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TTreeFriendLeafIter::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Tree_206_0_14, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TTreeFriendLeafIter::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Tree_206_0_15, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TTreeFriendLeafIter::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Tree_206_0_16, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TTreeFriendLeafIter::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__TreeLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (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__G__Tree_206_0_20, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Tree_206_0_21, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TTreeFriendLeafIter::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Tree_206_0_22, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TTreeFriendLeafIter::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Tree_206_0_23, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TTreeFriendLeafIter::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Tree_206_0_24, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TTreeFriendLeafIter::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TTreeFriendLeafIter", 1990, G__G__Tree_206_0_25, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTBranchObject(void) {
   /* TBranchObject */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__TreeLN_TBranchObject));
   G__memfunc_setup("Init",404,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 9, 1, 2, 0, 
"U 'TTree' - 0 - tree U 'TBranch' - 0 - parent "
"C - - 10 - name C - - 10 - classname "
"Y - - 0 - addobj i - 'Int_t' 0 - basketsize "
"i - 'Int_t' 0 - splitlevel i - 'Int_t' 0 - compress "
"g - 'Bool_t' 0 - isptrptr", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TBranchObject",1273,G__G__Tree_211_0_2, 105, G__get_linked_tagnum(&G__G__TreeLN_TBranchObject), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TBranchObject",1273,G__G__Tree_211_0_3, 105, G__get_linked_tagnum(&G__G__TreeLN_TBranchObject), -1, 0, 8, 1, 1, 0, 
"U 'TBranch' - 0 - parent C - - 10 - name "
"C - - 10 - classname Y - - 0 - addobj "
"i - 'Int_t' 0 '32000' basketsize i - 'Int_t' 0 '0' splitlevel "
"i - 'Int_t' 0 '-1' compress g - 'Bool_t' 0 'kTRUE' isptrptr", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TBranchObject",1273,G__G__Tree_211_0_4, 105, G__get_linked_tagnum(&G__G__TreeLN_TBranchObject), -1, 0, 8, 1, 1, 0, 
"U 'TTree' - 0 - tree C - - 10 - name "
"C - - 10 - classname Y - - 0 - addobj "
"i - 'Int_t' 0 '32000' basketsize i - 'Int_t' 0 '0' splitlevel "
"i - 'Int_t' 0 '-1' compress g - 'Bool_t' 0 'kTRUE' isptrptr", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Browse",626,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TBrowser' - 0 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Fill",391,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetClassName",1175,(G__InterfaceMethod) NULL,67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetObjClassName",1458,G__G__Tree_211_0_8, 67, -1, -1, 0, 0, 1, 1, 1, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetEntry",818,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 0, 
"n - 'Long64_t' 0 '0' entry i - 'Int_t' 0 '0' getall", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetExpectedType",1524,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 0, 
"U 'TClass' - 1 - clptr i 'EDataType' - 1 - type", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("IsFolder",792,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Print",525,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Reset",515,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetAddress",1010,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "Y - - 0 - addobj", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetAutoDelete",1304,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kTRUE' autodel", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetBasketSize",1313,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - buffsize", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetupAddresses",1455,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("UpdateAddress",1321,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Tree_211_0_19, 85, G__get_linked_tagnum(&G__G__TreeLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TBranchObject::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Tree_211_0_20, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TBranchObject::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Tree_211_0_21, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TBranchObject::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Tree_211_0_22, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TBranchObject::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__TreeLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (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__G__Tree_211_0_26, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Tree_211_0_27, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TBranchObject::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Tree_211_0_28, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TBranchObject::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Tree_211_0_29, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TBranchObject::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Tree_211_0_30, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TBranchObject::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TBranchObject", 1399, G__G__Tree_211_0_31, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTIndArray(void) {
   /* TIndArray */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__TreeLN_TIndArray));
   G__memfunc_setup("TIndArray",878,G__G__Tree_225_0_1, 105, G__get_linked_tagnum(&G__G__TreeLN_TIndArray), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Reserve",732,G__G__Tree_225_0_2, 121, -1, -1, 0, 1, 1, 1, 0, "h - 'UInt_t' 0 - size", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetCapacity",1102,G__G__Tree_225_0_3, 104, -1, G__defined_typename("UInt_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetNumItems",1106,G__G__Tree_225_0_4, 104, -1, G__defined_typename("UInt_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetNumItems",1118,G__G__Tree_225_0_5, 121, -1, -1, 0, 1, 1, 1, 0, "h - 'UInt_t' 0 - items", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("At",181,G__G__Tree_225_0_6, 98, -1, G__defined_typename("UChar_t"), 1, 1, 1, 1, 0, "i - 'Int_t' 0 - ind", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Clear",487,G__G__Tree_225_0_7, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   // automatic copy constructor
   G__memfunc_setup("TIndArray", 878, G__G__Tree_225_0_8, (int) ('i'), G__get_linked_tagnum(&G__G__TreeLN_TIndArray), -1, 0, 1, 1, 1, 0, "u 'TIndArray' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~TIndArray", 1004, G__G__Tree_225_0_9, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__G__Tree_225_0_10, (int) ('u'), G__get_linked_tagnum(&G__G__TreeLN_TIndArray), -1, 1, 1, 1, 1, 0, "u 'TIndArray' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTBranchSTL(void) {
   /* TBranchSTL */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__TreeLN_TBranchSTL));
   G__memfunc_setup("TBranchSTL",917,G__G__Tree_226_0_1, 105, G__get_linked_tagnum(&G__G__TreeLN_TBranchSTL), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TBranchSTL",917,G__G__Tree_226_0_2, 105, G__get_linked_tagnum(&G__G__TreeLN_TBranchSTL), -1, 0, 5, 1, 1, 0, 
"U 'TTree' - 0 - tree C - - 10 - name "
"U 'TVirtualCollectionProxy' - 0 - collProxy i - 'Int_t' 0 - buffsize "
"i - 'Int_t' 0 - splitlevel", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TBranchSTL",917,G__G__Tree_226_0_3, 105, G__get_linked_tagnum(&G__G__TreeLN_TBranchSTL), -1, 0, 7, 1, 1, 0, 
"U 'TBranch' - 0 - parent C - - 10 - name "
"U 'TVirtualCollectionProxy' - 0 - collProxy i - 'Int_t' 0 - buffsize "
"i - 'Int_t' 0 - splitlevel U 'TStreamerInfo' - 0 - info "
"i - 'Int_t' 0 - id", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Browse",626,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TBrowser' - 0 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("IsFolder",792,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Fill",391,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("FillLeaves",999,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetClassName",1175,(G__InterfaceMethod) NULL,67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetEntry",818,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 0, 
"n - 'Long64_t' 0 '0' entry i - 'Int_t' 0 '0' getall", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetInfo",684,G__G__Tree_226_0_10, 85, G__get_linked_tagnum(&G__G__TreeLN_TStreamerInfo), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Print",525,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "C - 'Option_t' 10 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetAddress",1010,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "Y - - 0 - addr", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Tree_226_0_13, 85, G__get_linked_tagnum(&G__G__TreeLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TBranchSTL::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Tree_226_0_14, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TBranchSTL::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Tree_226_0_15, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TBranchSTL::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Tree_226_0_16, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TBranchSTL::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__TreeLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (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__G__Tree_226_0_20, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Tree_226_0_21, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TBranchSTL::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Tree_226_0_22, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TBranchSTL::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Tree_226_0_23, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TBranchSTL::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Tree_226_0_24, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TBranchSTL::DeclFileLine) ), 0);
   G__memfunc_setup("ReadLeavesImpl",1390,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~TBranchSTL", 1043, G__G__Tree_226_0_26, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTChainElement(void) {
   /* TChainElement */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__TreeLN_TChainElement));
   G__memfunc_setup("TChainElement",1281,G__G__Tree_234_0_1, 105, G__get_linked_tagnum(&G__G__TreeLN_TChainElement), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TChainElement",1281,G__G__Tree_234_0_2, 105, G__get_linked_tagnum(&G__G__TreeLN_TChainElement), -1, 0, 2, 1, 1, 0, 
"C - - 10 - title C - - 10 - filename", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CreatePackets",1311,G__G__Tree_234_0_3, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetBaddress",1096,G__G__Tree_234_0_4, 89, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetBaddressClassName",1983,G__G__Tree_234_0_5, 67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetBaddressIsPtr",1594,G__G__Tree_234_0_6, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetBaddressType",1514,G__G__Tree_234_0_7, 104, -1, G__defined_typename("UInt_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetBranchPtr",1188,G__G__Tree_234_0_8, 85, G__get_linked_tagnum(&G__G__TreeLN_TBranch), -1, 2, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetEntries",1018,G__G__Tree_234_0_9, 110, -1, G__defined_typename("Long64_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetPackets",1003,G__G__Tree_234_0_10, 67, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetPacketSize",1299,G__G__Tree_234_0_11, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetStatus",932,G__G__Tree_234_0_12, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("HasBeenLookedUp",1465,G__G__Tree_234_0_13, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ls",223,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetBaddress",1108,G__G__Tree_234_0_15, 121, -1, -1, 0, 1, 1, 1, 0, "Y - - 0 - add", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetBaddressClassName",1995,G__G__Tree_234_0_16, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - clname", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetBaddressIsPtr",1606,G__G__Tree_234_0_17, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - isptr", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetBaddressType",1526,G__G__Tree_234_0_18, 121, -1, -1, 0, 1, 1, 1, 0, "h - 'UInt_t' 0 - type", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetBranchPtr",1200,G__G__Tree_234_0_19, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TBranch' - 2 - ptr", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetLookedUp",1103,G__G__Tree_234_0_20, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kTRUE' y", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetNumberEntries",1647,G__G__Tree_234_0_21, 121, -1, -1, 0, 1, 1, 1, 0, "n - 'Long64_t' 0 - n", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetPacketSize",1311,G__G__Tree_234_0_22, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 '100' size", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetStatus",944,G__G__Tree_234_0_23, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - status", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Tree_234_0_24, 85, G__get_linked_tagnum(&G__G__TreeLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TChainElement::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Tree_234_0_25, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TChainElement::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Tree_234_0_26, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TChainElement::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Tree_234_0_27, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TChainElement::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__TreeLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (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__G__Tree_234_0_31, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Tree_234_0_32, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TChainElement::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Tree_234_0_33, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TChainElement::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Tree_234_0_34, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TChainElement::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Tree_234_0_35, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TChainElement::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("TChainElement", 1281, G__G__Tree_234_0_36, (int) ('i'), G__get_linked_tagnum(&G__G__TreeLN_TChainElement), -1, 0, 1, 1, 1, 0, "u 'TChainElement' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~TChainElement", 1407, G__G__Tree_234_0_37, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__G__Tree_234_0_38, (int) ('u'), G__get_linked_tagnum(&G__G__TreeLN_TChainElement), -1, 1, 1, 1, 1, 0, "u 'TChainElement' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTChain(void) {
   /* TChain */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__TreeLN_TChain));
   G__memfunc_setup("TChain",567,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__TreeLN_TChain), -1, 0, 1, 1, 4, 0, "u 'TChain' - 11 - -", "not implemented", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__TreeLN_TChain), -1, 1, 1, 1, 4, 0, "u 'TChain' - 11 - -", "not implemented", (void*) NULL, 0);
   G__memfunc_setup("ReleaseChainProof",1706,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TChain",567,G__G__Tree_236_0_4, 105, G__get_linked_tagnum(&G__G__TreeLN_TChain), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TChain",567,G__G__Tree_236_0_5, 105, G__get_linked_tagnum(&G__G__TreeLN_TChain), -1, 0, 2, 1, 1, 0, 
"C - - 10 - name C - - 10 '\"\"' title", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Add",265,G__G__Tree_236_0_6, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "U 'TChain' - 0 - chain", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Add",265,G__G__Tree_236_0_7, 105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 0, 
"C - - 10 - name n - 'Long64_t' 0 'kBigNumber' nentries", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("AddFile",649,G__G__Tree_236_0_8, 105, -1, G__defined_typename("Int_t"), 0, 3, 1, 1, 0, 
"C - - 10 - name n - 'Long64_t' 0 'kBigNumber' nentries "
"C - - 10 '\"\"' tname", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("AddFileInfoList",1457,G__G__Tree_236_0_9, 105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 0, 
"U 'TCollection' - 0 - list n - 'Long64_t' 0 'kBigNumber' nfiles", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("AddFriend",865,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__TreeLN_TFriendElement), -1, 0, 2, 1, 1, 0, 
"C - - 10 - chainname C - - 10 '\"\"' dummy", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("AddFriend",865,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__TreeLN_TFriendElement), -1, 0, 2, 1, 1, 0, 
"C - - 10 - chainname U 'TFile' - 0 - dummy", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("AddFriend",865,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__TreeLN_TFriendElement), -1, 0, 3, 1, 1, 0, 
"U 'TTree' - 0 - chain C - - 10 '\"\"' alias "
"g - 'Bool_t' 0 'kFALSE' warn", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Browse",626,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TBrowser' - 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("CanDeleteRefs",1269,G__G__Tree_236_0_14, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kTRUE' flag", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("CreatePackets",1311,G__G__Tree_236_0_15, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DirectoryAutoAdd",1623,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TDirectory' - 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Draw",398,(G__InterfaceMethod) NULL,110, -1, G__defined_typename("Long64_t"), 0, 5, 1, 1, 0, 
"C - - 10 - varexp u 'TCut' - 11 - selection "
"C - 'Option_t' 10 '\"\"' option n - 'Long64_t' 0 'kBigNumber' nentries "
"n - 'Long64_t' 0 '0' firstentry", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Draw",398,(G__InterfaceMethod) NULL,110, -1, G__defined_typename("Long64_t"), 0, 5, 1, 1, 0, 
"C - - 10 - varexp C - - 10 - selection "
"C - 'Option_t' 10 '\"\"' option n - 'Long64_t' 0 'kBigNumber' nentries "
"n - 'Long64_t' 0 '0' firstentry", "*MENU*", (void*) NULL, 1);
   G__memfunc_setup("Draw",398,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 - opt", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Fill",391,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("FindBranch",975,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__TreeLN_TBranch), -1, 0, 1, 1, 1, 0, "C - - 10 - name", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("FindLeaf",761,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__TreeLN_TLeaf), -1, 0, 1, 1, 1, 0, "C - - 10 - name", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetBranch",878,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__TreeLN_TBranch), -1, 0, 1, 1, 1, 0, "C - - 10 - name", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetBranchStatus",1522,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 8, "C - - 10 - branchname", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetChainEntryNumber",1918,(G__InterfaceMethod) NULL,110, -1, G__defined_typename("Long64_t"), 0, 1, 1, 1, 8, "n - 'Long64_t' 0 - entry", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetNtrees",913,G__G__Tree_236_0_26, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetEntries",1018,(G__InterfaceMethod) NULL,110, -1, G__defined_typename("Long64_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetEntries",1018,(G__InterfaceMethod) NULL,110, -1, G__defined_typename("Long64_t"), 0, 1, 1, 1, 0, "C - - 10 - sel", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetEntry",818,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 0, 
"n - 'Long64_t' 0 '0' entry i - 'Int_t' 0 '0' getall", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetEntryNumber",1435,(G__InterfaceMethod) NULL,110, -1, G__defined_typename("Long64_t"), 0, 1, 1, 1, 8, "n - 'Long64_t' 0 - entry", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetEntryWithIndex",1734,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - major i - 'Int_t' 0 '0' minor", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetFile",672,G__G__Tree_236_0_32, 85, G__get_linked_tagnum(&G__G__TreeLN_TFile), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetLeaf",664,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__TreeLN_TLeaf), -1, 0, 1, 1, 1, 0, "C - - 10 - name", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetListOfBranches",1687,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__TreeLN_TObjArray), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetListOfFiles",1380,G__G__Tree_236_0_35, 85, G__get_linked_tagnum(&G__G__TreeLN_TObjArray), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetListOfLeaves",1489,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__TreeLN_TObjArray), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetAlias",778,(G__InterfaceMethod) NULL,67, -1, -1, 0, 1, 1, 1, 9, "C - - 10 - aliasName", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetMaximum",1022,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 0, "C - - 10 - columname", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetMinimum",1020,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 0, "C - - 10 - columname", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetNbranches",1204,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetReadEntry",1198,(G__InterfaceMethod) NULL,110, -1, G__defined_typename("Long64_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetStatus",932,G__G__Tree_236_0_42, 85, G__get_linked_tagnum(&G__G__TreeLN_TList), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetTree",688,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__TreeLN_TTree), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetTreeNumber",1305,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetTreeOffset",1303,G__G__Tree_236_0_45, 78, -1, G__defined_typename("Long64_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetTreeOffsetLen",1590,G__G__Tree_236_0_46, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetWeight",904,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("LoadBaskets",1101,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "n - 'Long64_t' 0 - maxmemory", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("LoadTree",784,(G__InterfaceMethod) NULL,110, -1, G__defined_typename("Long64_t"), 0, 1, 1, 1, 0, "n - 'Long64_t' 0 - entry", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Lookup",634,G__G__Tree_236_0_50, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kFALSE' force", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Loop",410,G__G__Tree_236_0_51, 121, -1, -1, 0, 3, 1, 1, 0, 
"C - 'Option_t' 10 '\"\"' option n - 'Long64_t' 0 'kBigNumber' nentries "
"n - 'Long64_t' 0 '0' firstentry", "*MENU*", (void*) NULL, 1);
   G__memfunc_setup("ls",223,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Merge",496,G__G__Tree_236_0_53, 110, -1, G__defined_typename("Long64_t"), 0, 2, 1, 1, 0, 
"C - - 10 - name C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Merge",496,(G__InterfaceMethod) NULL,110, -1, G__defined_typename("Long64_t"), 0, 2, 1, 1, 0, 
"U 'TCollection' - 0 - list C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Merge",496,G__G__Tree_236_0_55, 110, -1, G__defined_typename("Long64_t"), 0, 3, 1, 1, 0, 
"U 'TFile' - 0 - file i - 'Int_t' 0 - basketsize "
"C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Print",525,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Process",735,(G__InterfaceMethod) NULL,110, -1, G__defined_typename("Long64_t"), 0, 4, 1, 1, 0, 
"C - - 10 - filename C - 'Option_t' 10 '\"\"' option "
"n - 'Long64_t' 0 'kBigNumber' nentries n - 'Long64_t' 0 '0' firstentry", "*MENU*", (void*) NULL, 1);
   G__memfunc_setup("RecursiveRemove",1574,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TObject' - 0 - obj", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Reset",515,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ResetBranchAddress",1815,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TBranch' - 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ResetBranchAddresses",2031,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Scan",389,(G__InterfaceMethod) NULL,110, -1, G__defined_typename("Long64_t"), 0, 5, 1, 1, 0, 
"C - - 10 '\"\"' varexp C - - 10 '\"\"' selection "
"C - 'Option_t' 10 '\"\"' option n - 'Long64_t' 0 '1000000000' nentries "
"n - 'Long64_t' 0 '0' firstentry", "*MENU*", (void*) NULL, 1);
   G__memfunc_setup("SetAutoDelete",1304,G__G__Tree_236_0_63, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kTRUE' autodel", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetBranchAddress",1600,G__G__Tree_236_0_64, 105, -1, G__defined_typename("Int_t"), 0, 3, 1, 1, 0, 
"C - - 10 - bname Y - - 0 - add "
"U 'TBranch' - 2 '0' ptr", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetBranchAddress",1600,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 6, 1, 1, 0, 
"C - - 10 - bname Y - - 0 - add "
"U 'TBranch' - 2 - ptr U 'TClass' - 0 - realClass "
"i 'EDataType' - 0 - datatype g - 'Bool_t' 0 - isptr", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetBranchAddress",1600,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 5, 1, 1, 0, 
"C - - 10 - bname Y - - 0 - add "
"U 'TClass' - 0 - realClass i 'EDataType' - 0 - datatype "
"g - 'Bool_t' 0 - isptr", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetBranchStatus",1534,(G__InterfaceMethod) NULL,121, -1, -1, 0, 3, 1, 1, 0, 
"C - - 10 - bname g - 'Bool_t' 0 '1' status "
"H - 'UInt_t' 0 '0' found", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetDirectory",1249,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TDirectory' - 0 - dir", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetEntryList",1242,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"U 'TEntryList' - 0 - elist C - 'Option_t' 10 '\"\"' opt", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetEntryListFile",1626,G__G__Tree_236_0_70, 121, -1, -1, 0, 2, 1, 1, 0, 
"C - - 10 '\"\"' filename C - 'Option_t' 10 '\"\"' opt", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetEventList",1226,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TEventList' - 0 - evlist", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetMakeClass",1184,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - make", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetPacketSize",1311,G__G__Tree_236_0_73, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 '100' size", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetProof",818,G__G__Tree_236_0_74, 121, -1, -1, 0, 3, 1, 1, 0, 
"g - 'Bool_t' 0 'kTRUE' on g - 'Bool_t' 0 'kFALSE' refresh "
"g - 'Bool_t' 0 'kFALSE' gettreeheader", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetWeight",916,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"d - 'Double_t' 0 '1' w C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("UseCache",769,G__G__Tree_236_0_76, 121, -1, -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 '10' maxCacheSize i - 'Int_t' 0 '0' pageSize", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Tree_236_0_77, 85, G__get_linked_tagnum(&G__G__TreeLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TChain::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Tree_236_0_78, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TChain::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Tree_236_0_79, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TChain::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Tree_236_0_80, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TChain::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__TreeLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (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__G__Tree_236_0_84, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Tree_236_0_85, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TChain::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Tree_236_0_86, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TChain::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Tree_236_0_87, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TChain::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Tree_236_0_88, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TChain::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TChain", 693, G__G__Tree_236_0_89, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTEntryListBlock(void) {
   /* TEntryListBlock */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__TreeLN_TEntryListBlock));
   G__memfunc_setup("Transform",956,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 2, 1, 2, 0, 
"g - 'Bool_t' 0 - dir R - 'UShort_t' 0 - indexnew", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TEntryListBlock",1517,G__G__Tree_238_0_2, 105, G__get_linked_tagnum(&G__G__TreeLN_TEntryListBlock), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TEntryListBlock",1517,G__G__Tree_238_0_3, 105, G__get_linked_tagnum(&G__G__TreeLN_TEntryListBlock), -1, 0, 1, 1, 1, 0, "u 'TEntryListBlock' - 11 - eblock", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Enter",510,G__G__Tree_238_0_4, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "i - 'Int_t' 0 - entry", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Remove",622,G__G__Tree_238_0_5, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "i - 'Int_t' 0 - entry", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Contains",831,G__G__Tree_238_0_6, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "i - 'Int_t' 0 - entry", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("OptimizeStorage",1574,G__G__Tree_238_0_7, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Merge",496,G__G__Tree_238_0_8, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "U 'TEntryListBlock' - 0 - block", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Next",415,G__G__Tree_238_0_9, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetEntry",818,G__G__Tree_238_0_10, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "i - 'Int_t' 0 - entry", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ResetIndices",1218,G__G__Tree_238_0_11, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetType",706,G__G__Tree_238_0_12, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetNPassed",974,G__G__Tree_238_0_13, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Print",525,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("PrintWithShift",1447,G__G__Tree_238_0_15, 121, -1, -1, 0, 1, 1, 1, 8, "i - 'Int_t' 0 - shift", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Tree_238_0_16, 85, G__get_linked_tagnum(&G__G__TreeLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TEntryListBlock::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Tree_238_0_17, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEntryListBlock::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Tree_238_0_18, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TEntryListBlock::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Tree_238_0_19, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TEntryListBlock::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__TreeLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (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__G__Tree_238_0_23, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Tree_238_0_24, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEntryListBlock::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Tree_238_0_25, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEntryListBlock::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Tree_238_0_26, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEntryListBlock::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Tree_238_0_27, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEntryListBlock::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TEntryListBlock", 1643, G__G__Tree_238_0_28, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__G__Tree_238_0_29, (int) ('u'), G__get_linked_tagnum(&G__G__TreeLN_TEntryListBlock), -1, 1, 1, 1, 1, 0, "u 'TEntryListBlock' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTEntryListFromFile(void) {
   /* TEntryListFromFile */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__TreeLN_TEntryListFromFile));
   G__memfunc_setup("TEntryListFromFile",1814,G__G__Tree_241_0_1, 105, G__get_linked_tagnum(&G__G__TreeLN_TEntryListFromFile), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TEntryListFromFile",1814,G__G__Tree_241_0_2, 105, G__get_linked_tagnum(&G__G__TreeLN_TEntryListFromFile), -1, 0, 3, 1, 1, 0, 
"C - - 10 - filename C - - 10 - listname "
"i - 'Int_t' 0 - nfiles", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Add",265,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TEntryList' - 10 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Contains",831,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 0, 
"n - 'Long64_t' 0 - - U 'TTree' - 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Enter",510,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 2, 1, 1, 0, 
"n - 'Long64_t' 0 - - U 'TTree' - 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetCurrentList",1439,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__TreeLN_TEntryList), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetEntryList",1230,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__TreeLN_TEntryList), -1, 0, 3, 1, 1, 0, 
"C - - 10 - - C - - 10 - - "
"C - 'Option_t' 10 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetEntry",818,(G__InterfaceMethod) NULL,110, -1, G__defined_typename("Long64_t"), 0, 1, 1, 1, 0, "i - 'Int_t' 0 - index", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetEntryAndTree",1493,(G__InterfaceMethod) NULL,110, -1, G__defined_typename("Long64_t"), 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - index i - 'Int_t' 1 - treenum", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetEntries",1018,G__G__Tree_241_0_10, 110, -1, G__defined_typename("Long64_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetEntriesFast",1416,G__G__Tree_241_0_11, 110, -1, G__defined_typename("Long64_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetN",366,(G__InterfaceMethod) NULL,110, -1, G__defined_typename("Long64_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetTreeName",1073,(G__InterfaceMethod) NULL,67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetFileName",1057,(G__InterfaceMethod) NULL,67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetTreeNumber",1305,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("LoadList",796,G__G__Tree_241_0_16, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "i - 'Int_t' 0 - listnumber", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Merge",496,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "U 'TCollection' - 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Next",415,(G__InterfaceMethod) NULL,110, -1, G__defined_typename("Long64_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("OptimizeStorage",1574,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Remove",622,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 2, 1, 1, 0, 
"n - 'Long64_t' 0 - - U 'TTree' - 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Print",525,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetTree",700,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TTree' - 10 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetTree",700,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"C - - 10 - - C - - 10 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetFileNames",1184,G__G__Tree_241_0_24, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TObjArray' - 0 - names", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetTreeNumber",1317,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - index", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetNFiles",877,G__G__Tree_241_0_26, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - nfiles", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Subtract",840,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TEntryList' - 10 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Tree_241_0_28, 85, G__get_linked_tagnum(&G__G__TreeLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TEntryListFromFile::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Tree_241_0_29, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEntryListFromFile::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Tree_241_0_30, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TEntryListFromFile::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Tree_241_0_31, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TEntryListFromFile::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__TreeLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (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__G__Tree_241_0_35, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Tree_241_0_36, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEntryListFromFile::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Tree_241_0_37, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEntryListFromFile::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Tree_241_0_38, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEntryListFromFile::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Tree_241_0_39, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEntryListFromFile::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("TEntryListFromFile", 1814, G__G__Tree_241_0_40, (int) ('i'), G__get_linked_tagnum(&G__G__TreeLN_TEntryListFromFile), -1, 0, 1, 1, 1, 0, "u 'TEntryListFromFile' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~TEntryListFromFile", 1940, G__G__Tree_241_0_41, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTLeafB(void) {
   /* TLeafB */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__TreeLN_TLeafB));
   G__memfunc_setup("TLeafB",526,G__G__Tree_245_0_1, 105, G__get_linked_tagnum(&G__G__TreeLN_TLeafB), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TLeafB",526,G__G__Tree_245_0_2, 105, G__get_linked_tagnum(&G__G__TreeLN_TLeafB), -1, 0, 3, 1, 1, 0, 
"U 'TBranch' - 0 - parent C - - 10 - name "
"C - - 10 - type", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Export",642,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"U 'TClonesArray' - 0 - list i - 'Int_t' 0 - n", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("FillBasket",993,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetMaximum",1022,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetMinimum",1020,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetTypeName",1091,(G__InterfaceMethod) NULL,67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetValue",797,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 0 '0' i", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetValuePointer",1534,(G__InterfaceMethod) NULL,89, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Import",635,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"U 'TClonesArray' - 0 - list i - 'Int_t' 0 - n", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("PrintValue",1034,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "i - 'Int_t' 0 '0' i", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ReadBasket",982,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ReadBasketExport",1624,(G__InterfaceMethod) NULL,121, -1, -1, 0, 3, 1, 1, 0, 
"u 'TBuffer' - 1 - - U 'TClonesArray' - 0 - list "
"i - 'Int_t' 0 - n", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ReadValue",889,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'basic_istream<char,char_traits<char> >' 'istream' 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetAddress",1010,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "Y - - 0 '0' addr", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetMaximum",1034,G__G__Tree_245_0_16, 121, -1, -1, 0, 1, 1, 1, 0, "c - 'Char_t' 0 - max", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetMinimum",1032,G__G__Tree_245_0_17, 121, -1, -1, 0, 1, 1, 1, 0, "c - 'Char_t' 0 - min", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Tree_245_0_18, 85, G__get_linked_tagnum(&G__G__TreeLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TLeafB::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Tree_245_0_19, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TLeafB::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Tree_245_0_20, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TLeafB::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Tree_245_0_21, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TLeafB::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__TreeLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (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__G__Tree_245_0_25, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Tree_245_0_26, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TLeafB::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Tree_245_0_27, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TLeafB::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Tree_245_0_28, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TLeafB::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Tree_245_0_29, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TLeafB::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("TLeafB", 526, G__G__Tree_245_0_30, (int) ('i'), G__get_linked_tagnum(&G__G__TreeLN_TLeafB), -1, 0, 1, 1, 1, 0, "u 'TLeafB' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~TLeafB", 652, G__G__Tree_245_0_31, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTLeafC(void) {
   /* TLeafC */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__TreeLN_TLeafC));
   G__memfunc_setup("TLeafC",527,G__G__Tree_246_0_1, 105, G__get_linked_tagnum(&G__G__TreeLN_TLeafC), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TLeafC",527,G__G__Tree_246_0_2, 105, G__get_linked_tagnum(&G__G__TreeLN_TLeafC), -1, 0, 3, 1, 1, 0, 
"U 'TBranch' - 0 - parent C - - 10 - name "
"C - - 10 - type", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Export",642,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"U 'TClonesArray' - 0 - list i - 'Int_t' 0 - n", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("FillBasket",993,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetMaximum",1022,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetMinimum",1020,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetTypeName",1091,(G__InterfaceMethod) NULL,67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetValue",797,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 0 '0' i", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetValuePointer",1534,(G__InterfaceMethod) NULL,89, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetValueString",1428,G__G__Tree_246_0_10, 67, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Import",635,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"U 'TClonesArray' - 0 - list i - 'Int_t' 0 - n", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("PrintValue",1034,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "i - 'Int_t' 0 '0' i", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ReadBasket",982,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ReadBasketExport",1624,(G__InterfaceMethod) NULL,121, -1, -1, 0, 3, 1, 1, 0, 
"u 'TBuffer' - 1 - b U 'TClonesArray' - 0 - list "
"i - 'Int_t' 0 - n", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ReadValue",889,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'basic_istream<char,char_traits<char> >' 'istream' 1 - s", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetAddress",1010,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "Y - - 0 '0' add", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Tree_246_0_17, 85, G__get_linked_tagnum(&G__G__TreeLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TLeafC::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Tree_246_0_18, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TLeafC::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Tree_246_0_19, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TLeafC::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Tree_246_0_20, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TLeafC::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__TreeLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (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__G__Tree_246_0_24, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Tree_246_0_25, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TLeafC::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Tree_246_0_26, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TLeafC::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Tree_246_0_27, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TLeafC::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Tree_246_0_28, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TLeafC::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("TLeafC", 527, G__G__Tree_246_0_29, (int) ('i'), G__get_linked_tagnum(&G__G__TreeLN_TLeafC), -1, 0, 1, 1, 1, 0, "u 'TLeafC' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~TLeafC", 653, G__G__Tree_246_0_30, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTLeafD(void) {
   /* TLeafD */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__TreeLN_TLeafD));
   G__memfunc_setup("TLeafD",528,G__G__Tree_247_0_1, 105, G__get_linked_tagnum(&G__G__TreeLN_TLeafD), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TLeafD",528,G__G__Tree_247_0_2, 105, G__get_linked_tagnum(&G__G__TreeLN_TLeafD), -1, 0, 3, 1, 1, 0, 
"U 'TBranch' - 0 - parent C - - 10 - name "
"C - - 10 - type", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Export",642,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"U 'TClonesArray' - 0 - list i - 'Int_t' 0 - n", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("FillBasket",993,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetTypeName",1091,(G__InterfaceMethod) NULL,67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetValue",797,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 0 '0' i", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetValuePointer",1534,(G__InterfaceMethod) NULL,89, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Import",635,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"U 'TClonesArray' - 0 - list i - 'Int_t' 0 - n", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("PrintValue",1034,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "i - 'Int_t' 0 '0' i", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ReadBasket",982,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ReadBasketExport",1624,(G__InterfaceMethod) NULL,121, -1, -1, 0, 3, 1, 1, 0, 
"u 'TBuffer' - 1 - b U 'TClonesArray' - 0 - list "
"i - 'Int_t' 0 - n", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ReadValue",889,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'basic_istream<char,char_traits<char> >' 'istream' 1 - s", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetAddress",1010,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "Y - - 0 '0' add", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Tree_247_0_14, 85, G__get_linked_tagnum(&G__G__TreeLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TLeafD::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Tree_247_0_15, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TLeafD::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Tree_247_0_16, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TLeafD::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Tree_247_0_17, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TLeafD::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__TreeLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (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__G__Tree_247_0_21, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Tree_247_0_22, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TLeafD::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Tree_247_0_23, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TLeafD::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Tree_247_0_24, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TLeafD::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Tree_247_0_25, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TLeafD::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("TLeafD", 528, G__G__Tree_247_0_26, (int) ('i'), G__get_linked_tagnum(&G__G__TreeLN_TLeafD), -1, 0, 1, 1, 1, 0, "u 'TLeafD' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~TLeafD", 654, G__G__Tree_247_0_27, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTLeafElement(void) {
   /* TLeafElement */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__TreeLN_TLeafElement));
   G__memfunc_setup("TLeafElement",1174,G__G__Tree_248_0_1, 105, G__get_linked_tagnum(&G__G__TreeLN_TLeafElement), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TLeafElement",1174,G__G__Tree_248_0_2, 105, G__get_linked_tagnum(&G__G__TreeLN_TLeafElement), -1, 0, 4, 1, 1, 0, 
"U 'TBranch' - 0 - parent C - - 10 - name "
"i - 'Int_t' 0 - id i - 'Int_t' 0 - type", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetLen",575,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetMethodCall",1277,G__G__Tree_248_0_4, 85, G__get_linked_tagnum(&G__G__TreeLN_TMethodCall), -1, 0, 1, 1, 1, 0, "C - - 10 - name", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMaximum",1022,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetNdata",776,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetTypeName",1091,(G__InterfaceMethod) NULL,67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetValue",797,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 0 '0' i", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetValueSubArray",1606,G__G__Tree_248_0_9, 100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 8, 
"i - 'Int_t' 0 '0' i i - 'Int_t' 0 '0' j", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetValuePointer",1534,(G__InterfaceMethod) NULL,89, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("IsOnTerminalBranch",1795,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("PrintValue",1034,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "i - 'Int_t' 0 '0' i", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetLeafCount",1197,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TLeaf' - 0 - leaf", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Tree_248_0_14, 85, G__get_linked_tagnum(&G__G__TreeLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TLeafElement::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Tree_248_0_15, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TLeafElement::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Tree_248_0_16, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TLeafElement::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Tree_248_0_17, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TLeafElement::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__TreeLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (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__G__Tree_248_0_21, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Tree_248_0_22, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TLeafElement::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Tree_248_0_23, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TLeafElement::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Tree_248_0_24, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TLeafElement::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Tree_248_0_25, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TLeafElement::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("TLeafElement", 1174, G__G__Tree_248_0_26, (int) ('i'), G__get_linked_tagnum(&G__G__TreeLN_TLeafElement), -1, 0, 1, 1, 1, 0, "u 'TLeafElement' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~TLeafElement", 1300, G__G__Tree_248_0_27, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTLeafF(void) {
   /* TLeafF */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__TreeLN_TLeafF));
   G__memfunc_setup("TLeafF",530,G__G__Tree_249_0_1, 105, G__get_linked_tagnum(&G__G__TreeLN_TLeafF), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TLeafF",530,G__G__Tree_249_0_2, 105, G__get_linked_tagnum(&G__G__TreeLN_TLeafF), -1, 0, 3, 1, 1, 0, 
"U 'TBranch' - 0 - parent C - - 10 - name "
"C - - 10 - type", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Export",642,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"U 'TClonesArray' - 0 - list i - 'Int_t' 0 - n", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("FillBasket",993,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetTypeName",1091,(G__InterfaceMethod) NULL,67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetValue",797,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 0 '0' i", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetValuePointer",1534,(G__InterfaceMethod) NULL,89, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Import",635,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"U 'TClonesArray' - 0 - list i - 'Int_t' 0 - n", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("PrintValue",1034,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "i - 'Int_t' 0 '0' i", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ReadBasket",982,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ReadBasketExport",1624,(G__InterfaceMethod) NULL,121, -1, -1, 0, 3, 1, 1, 0, 
"u 'TBuffer' - 1 - b U 'TClonesArray' - 0 - list "
"i - 'Int_t' 0 - n", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ReadValue",889,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'basic_istream<char,char_traits<char> >' 'istream' 1 - s", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetAddress",1010,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "Y - - 0 '0' add", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Tree_249_0_14, 85, G__get_linked_tagnum(&G__G__TreeLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TLeafF::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Tree_249_0_15, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TLeafF::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Tree_249_0_16, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TLeafF::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Tree_249_0_17, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TLeafF::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__TreeLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (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__G__Tree_249_0_21, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Tree_249_0_22, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TLeafF::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Tree_249_0_23, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TLeafF::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Tree_249_0_24, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TLeafF::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Tree_249_0_25, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TLeafF::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("TLeafF", 530, G__G__Tree_249_0_26, (int) ('i'), G__get_linked_tagnum(&G__G__TreeLN_TLeafF), -1, 0, 1, 1, 1, 0, "u 'TLeafF' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~TLeafF", 656, G__G__Tree_249_0_27, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTLeafI(void) {
   /* TLeafI */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__TreeLN_TLeafI));
   G__memfunc_setup("TLeafI",533,G__G__Tree_250_0_1, 105, G__get_linked_tagnum(&G__G__TreeLN_TLeafI), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TLeafI",533,G__G__Tree_250_0_2, 105, G__get_linked_tagnum(&G__G__TreeLN_TLeafI), -1, 0, 3, 1, 1, 0, 
"U 'TBranch' - 0 - parent C - - 10 - name "
"C - - 10 - type", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Export",642,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"U 'TClonesArray' - 0 - list i - 'Int_t' 0 - n", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("FillBasket",993,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetTypeName",1091,(G__InterfaceMethod) NULL,67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetMaximum",1022,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetMinimum",1020,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetValue",797,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 0 '0' i", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetValuePointer",1534,(G__InterfaceMethod) NULL,89, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Import",635,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"U 'TClonesArray' - 0 - list i - 'Int_t' 0 - n", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("PrintValue",1034,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "i - 'Int_t' 0 '0' i", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ReadBasket",982,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ReadBasketExport",1624,(G__InterfaceMethod) NULL,121, -1, -1, 0, 3, 1, 1, 0, 
"u 'TBuffer' - 1 - b U 'TClonesArray' - 0 - list "
"i - 'Int_t' 0 - n", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ReadValue",889,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'basic_istream<char,char_traits<char> >' 'istream' 1 - s", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetAddress",1010,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "Y - - 0 '0' add", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetMaximum",1034,G__G__Tree_250_0_16, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - max", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetMinimum",1032,G__G__Tree_250_0_17, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - min", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Tree_250_0_18, 85, G__get_linked_tagnum(&G__G__TreeLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TLeafI::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Tree_250_0_19, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TLeafI::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Tree_250_0_20, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TLeafI::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Tree_250_0_21, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TLeafI::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__TreeLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (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__G__Tree_250_0_25, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Tree_250_0_26, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TLeafI::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Tree_250_0_27, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TLeafI::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Tree_250_0_28, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TLeafI::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Tree_250_0_29, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TLeafI::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("TLeafI", 533, G__G__Tree_250_0_30, (int) ('i'), G__get_linked_tagnum(&G__G__TreeLN_TLeafI), -1, 0, 1, 1, 1, 0, "u 'TLeafI' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~TLeafI", 659, G__G__Tree_250_0_31, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTLeafL(void) {
   /* TLeafL */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__TreeLN_TLeafL));
   G__memfunc_setup("TLeafL",536,G__G__Tree_251_0_1, 105, G__get_linked_tagnum(&G__G__TreeLN_TLeafL), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TLeafL",536,G__G__Tree_251_0_2, 105, G__get_linked_tagnum(&G__G__TreeLN_TLeafL), -1, 0, 3, 1, 1, 0, 
"U 'TBranch' - 0 - parent C - - 10 - name "
"C - - 10 - type", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Export",642,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"U 'TClonesArray' - 0 - list i - 'Int_t' 0 - n", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("FillBasket",993,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetTypeName",1091,(G__InterfaceMethod) NULL,67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetMaximum",1022,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetMinimum",1020,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetValue",797,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 0 '0' i", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetValuePointer",1534,(G__InterfaceMethod) NULL,89, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Import",635,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"U 'TClonesArray' - 0 - list i - 'Int_t' 0 - n", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("PrintValue",1034,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "i - 'Int_t' 0 '0' i", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ReadBasket",982,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ReadBasketExport",1624,(G__InterfaceMethod) NULL,121, -1, -1, 0, 3, 1, 1, 0, 
"u 'TBuffer' - 1 - b U 'TClonesArray' - 0 - list "
"i - 'Int_t' 0 - n", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ReadValue",889,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'basic_istream<char,char_traits<char> >' 'istream' 1 - s", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetAddress",1010,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "Y - - 0 '0' add", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetMaximum",1034,G__G__Tree_251_0_16, 121, -1, -1, 0, 1, 1, 1, 0, "n - 'Long64_t' 0 - max", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetMinimum",1032,G__G__Tree_251_0_17, 121, -1, -1, 0, 1, 1, 1, 0, "n - 'Long64_t' 0 - min", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Tree_251_0_18, 85, G__get_linked_tagnum(&G__G__TreeLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TLeafL::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Tree_251_0_19, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TLeafL::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Tree_251_0_20, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TLeafL::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Tree_251_0_21, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TLeafL::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__TreeLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (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__G__Tree_251_0_25, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Tree_251_0_26, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TLeafL::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Tree_251_0_27, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TLeafL::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Tree_251_0_28, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TLeafL::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Tree_251_0_29, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TLeafL::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("TLeafL", 536, G__G__Tree_251_0_30, (int) ('i'), G__get_linked_tagnum(&G__G__TreeLN_TLeafL), -1, 0, 1, 1, 1, 0, "u 'TLeafL' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~TLeafL", 662, G__G__Tree_251_0_31, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTLeafObject(void) {
   /* TLeafObject */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__TreeLN_TLeafObject));
   G__memfunc_setup("TLeafObject",1059,G__G__Tree_252_0_1, 105, G__get_linked_tagnum(&G__G__TreeLN_TLeafObject), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TLeafObject",1059,G__G__Tree_252_0_2, 105, G__get_linked_tagnum(&G__G__TreeLN_TLeafObject), -1, 0, 3, 1, 1, 0, 
"U 'TBranch' - 0 - parent C - - 10 - name "
"C - - 10 - type", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("FillBasket",993,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetClass",790,G__G__Tree_252_0_4, 85, G__get_linked_tagnum(&G__G__TreeLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMethodCall",1277,G__G__Tree_252_0_5, 85, G__get_linked_tagnum(&G__G__TreeLN_TMethodCall), -1, 0, 1, 1, 1, 0, "C - - 10 - name", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetObject",887,G__G__Tree_252_0_6, 85, G__get_linked_tagnum(&G__G__TreeLN_TObject), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetTypeName",1091,(G__InterfaceMethod) NULL,67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetValuePointer",1534,(G__InterfaceMethod) NULL,89, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("IsOnTerminalBranch",1795,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("IsVirtual",931,G__G__Tree_252_0_10, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Notify",633,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("PrintValue",1034,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "i - 'Int_t' 0 '0' i", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ReadBasket",982,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetAddress",1010,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "Y - - 0 '0' add", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetVirtual",1043,G__G__Tree_252_0_15, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kTRUE' virt", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Tree_252_0_16, 85, G__get_linked_tagnum(&G__G__TreeLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TLeafObject::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Tree_252_0_17, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TLeafObject::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Tree_252_0_18, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TLeafObject::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Tree_252_0_19, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TLeafObject::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__TreeLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (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__G__Tree_252_0_23, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Tree_252_0_24, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TLeafObject::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Tree_252_0_25, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TLeafObject::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Tree_252_0_26, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TLeafObject::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Tree_252_0_27, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TLeafObject::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("TLeafObject", 1059, G__G__Tree_252_0_28, (int) ('i'), G__get_linked_tagnum(&G__G__TreeLN_TLeafObject), -1, 0, 1, 1, 1, 0, "u 'TLeafObject' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~TLeafObject", 1185, G__G__Tree_252_0_29, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTLeafO(void) {
   /* TLeafO */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__TreeLN_TLeafO));
   G__memfunc_setup("TLeafO",539,G__G__Tree_254_0_1, 105, G__get_linked_tagnum(&G__G__TreeLN_TLeafO), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TLeafO",539,G__G__Tree_254_0_2, 105, G__get_linked_tagnum(&G__G__TreeLN_TLeafO), -1, 0, 3, 1, 1, 0, 
"U 'TBranch' - 0 - parent C - - 10 - name "
"C - - 10 - type", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Export",642,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"U 'TClonesArray' - 0 - list i - 'Int_t' 0 - n", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("FillBasket",993,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetTypeName",1091,(G__InterfaceMethod) NULL,67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetValue",797,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 0 '0' i", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetValuePointer",1534,(G__InterfaceMethod) NULL,89, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Import",635,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"U 'TClonesArray' - 0 - list i - 'Int_t' 0 - n", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("PrintValue",1034,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "i - 'Int_t' 0 '0' i", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ReadBasket",982,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ReadBasketExport",1624,(G__InterfaceMethod) NULL,121, -1, -1, 0, 3, 1, 1, 0, 
"u 'TBuffer' - 1 - b U 'TClonesArray' - 0 - list "
"i - 'Int_t' 0 - n", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ReadValue",889,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'basic_istream<char,char_traits<char> >' 'istream' 1 - s", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetAddress",1010,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "Y - - 0 '0' add", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Tree_254_0_14, 85, G__get_linked_tagnum(&G__G__TreeLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TLeafO::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Tree_254_0_15, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TLeafO::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Tree_254_0_16, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TLeafO::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Tree_254_0_17, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TLeafO::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__TreeLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (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__G__Tree_254_0_21, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Tree_254_0_22, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TLeafO::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Tree_254_0_23, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TLeafO::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Tree_254_0_24, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TLeafO::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Tree_254_0_25, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TLeafO::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("TLeafO", 539, G__G__Tree_254_0_26, (int) ('i'), G__get_linked_tagnum(&G__G__TreeLN_TLeafO), -1, 0, 1, 1, 1, 0, "u 'TLeafO' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~TLeafO", 665, G__G__Tree_254_0_27, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTLeafS(void) {
   /* TLeafS */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__TreeLN_TLeafS));
   G__memfunc_setup("TLeafS",543,G__G__Tree_255_0_1, 105, G__get_linked_tagnum(&G__G__TreeLN_TLeafS), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TLeafS",543,G__G__Tree_255_0_2, 105, G__get_linked_tagnum(&G__G__TreeLN_TLeafS), -1, 0, 3, 1, 1, 0, 
"U 'TBranch' - 0 - parent C - - 10 - name "
"C - - 10 - type", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Export",642,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"U 'TClonesArray' - 0 - list i - 'Int_t' 0 - n", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("FillBasket",993,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetTypeName",1091,(G__InterfaceMethod) NULL,67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetValue",797,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 0 '0' i", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetValuePointer",1534,(G__InterfaceMethod) NULL,89, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Import",635,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"U 'TClonesArray' - 0 - list i - 'Int_t' 0 - n", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("PrintValue",1034,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "i - 'Int_t' 0 '0' i", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ReadBasket",982,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ReadBasketExport",1624,(G__InterfaceMethod) NULL,121, -1, -1, 0, 3, 1, 1, 0, 
"u 'TBuffer' - 1 - b U 'TClonesArray' - 0 - list "
"i - 'Int_t' 0 - n", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ReadValue",889,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'basic_istream<char,char_traits<char> >' 'istream' 1 - s", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetAddress",1010,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "Y - - 0 '0' add", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Tree_255_0_14, 85, G__get_linked_tagnum(&G__G__TreeLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TLeafS::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Tree_255_0_15, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TLeafS::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Tree_255_0_16, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TLeafS::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Tree_255_0_17, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TLeafS::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__TreeLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (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__G__Tree_255_0_21, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Tree_255_0_22, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TLeafS::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Tree_255_0_23, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TLeafS::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Tree_255_0_24, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TLeafS::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Tree_255_0_25, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TLeafS::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("TLeafS", 543, G__G__Tree_255_0_26, (int) ('i'), G__get_linked_tagnum(&G__G__TreeLN_TLeafS), -1, 0, 1, 1, 1, 0, "u 'TLeafS' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~TLeafS", 669, G__G__Tree_255_0_27, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTNtupleD(void) {
   /* TNtupleD */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__TreeLN_TNtupleD));
   G__memfunc_setup("Fill",391,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("TNtupleD",784,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__TreeLN_TNtupleD), -1, 0, 1, 1, 4, 0, "u 'TNtupleD' - 11 - -", "not implemented", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__TreeLN_TNtupleD), -1, 1, 1, 1, 4, 0, "u 'TNtupleD' - 11 - -", "not implemented", (void*) NULL, 0);
   G__memfunc_setup("TNtupleD",784,G__G__Tree_256_0_4, 105, G__get_linked_tagnum(&G__G__TreeLN_TNtupleD), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TNtupleD",784,G__G__Tree_256_0_5, 105, G__get_linked_tagnum(&G__G__TreeLN_TNtupleD), -1, 0, 4, 1, 1, 0, 
"C - - 10 - name C - - 10 - title "
"C - - 10 - varlist i - 'Int_t' 0 '32000' bufsize", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Browse",626,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TBrowser' - 0 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Fill",391,G__G__Tree_256_0_7, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "D - 'Double_t' 10 - x", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Fill",391,G__G__Tree_256_0_8, 105, -1, G__defined_typename("Int_t"), 0, 15, 1, 1, 0, 
"d - 'Double_t' 0 - x0 d - 'Double_t' 0 - x1 "
"d - 'Double_t' 0 '0' x2 d - 'Double_t' 0 '0' x3 "
"d - 'Double_t' 0 '0' x4 d - 'Double_t' 0 '0' x5 "
"d - 'Double_t' 0 '0' x6 d - 'Double_t' 0 '0' x7 "
"d - 'Double_t' 0 '0' x8 d - 'Double_t' 0 '0' x9 "
"d - 'Double_t' 0 '0' x10 d - 'Double_t' 0 '0' x11 "
"d - 'Double_t' 0 '0' x12 d - 'Double_t' 0 '0' x13 "
"d - 'Double_t' 0 '0' x14", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetNvar",695,G__G__Tree_256_0_9, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetArgs",685,G__G__Tree_256_0_10, 68, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ReadFile",764,(G__InterfaceMethod) NULL,110, -1, G__defined_typename("Long64_t"), 0, 2, 1, 1, 0, 
"C - - 10 - filename C - - 10 '\"\"' branchDescriptor", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ResetBranchAddress",1815,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TBranch' - 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ResetBranchAddresses",2031,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Tree_256_0_14, 85, G__get_linked_tagnum(&G__G__TreeLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TNtupleD::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Tree_256_0_15, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TNtupleD::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Tree_256_0_16, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TNtupleD::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Tree_256_0_17, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TNtupleD::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__TreeLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (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__G__Tree_256_0_21, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Tree_256_0_22, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TNtupleD::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Tree_256_0_23, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TNtupleD::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Tree_256_0_24, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TNtupleD::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Tree_256_0_25, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TNtupleD::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TNtupleD", 910, G__G__Tree_256_0_26, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTNtuple(void) {
   /* TNtuple */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__TreeLN_TNtuple));
   G__memfunc_setup("Fill",391,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("TNtuple",716,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__TreeLN_TNtuple), -1, 0, 1, 1, 4, 0, "u 'TNtuple' - 11 - -", "not implemented", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__TreeLN_TNtuple), -1, 1, 1, 1, 4, 0, "u 'TNtuple' - 11 - -", "not implmeneted", (void*) NULL, 0);
   G__memfunc_setup("TNtuple",716,G__G__Tree_257_0_4, 105, G__get_linked_tagnum(&G__G__TreeLN_TNtuple), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TNtuple",716,G__G__Tree_257_0_5, 105, G__get_linked_tagnum(&G__G__TreeLN_TNtuple), -1, 0, 4, 1, 1, 0, 
"C - - 10 - name C - - 10 - title "
"C - - 10 - varlist i - 'Int_t' 0 '32000' bufsize", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Browse",626,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TBrowser' - 0 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Fill",391,G__G__Tree_257_0_7, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "F - 'Float_t' 10 - x", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Fill",391,G__G__Tree_257_0_8, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "i - 'Int_t' 0 - x0", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Fill",391,G__G__Tree_257_0_9, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "d - 'Double_t' 0 - x0", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Fill",391,G__G__Tree_257_0_10, 105, -1, G__defined_typename("Int_t"), 0, 15, 1, 1, 0, 
"f - 'Float_t' 0 - x0 f - 'Float_t' 0 '0' x1 "
"f - 'Float_t' 0 '0' x2 f - 'Float_t' 0 '0' x3 "
"f - 'Float_t' 0 '0' x4 f - 'Float_t' 0 '0' x5 "
"f - 'Float_t' 0 '0' x6 f - 'Float_t' 0 '0' x7 "
"f - 'Float_t' 0 '0' x8 f - 'Float_t' 0 '0' x9 "
"f - 'Float_t' 0 '0' x10 f - 'Float_t' 0 '0' x11 "
"f - 'Float_t' 0 '0' x12 f - 'Float_t' 0 '0' x13 "
"f - 'Float_t' 0 '0' x14", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetNvar",695,G__G__Tree_257_0_11, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetArgs",685,G__G__Tree_257_0_12, 70, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ReadFile",764,(G__InterfaceMethod) NULL,110, -1, G__defined_typename("Long64_t"), 0, 2, 1, 1, 0, 
"C - - 10 - filename C - - 10 '\"\"' branchDescriptor", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ResetBranchAddress",1815,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TBranch' - 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ResetBranchAddresses",2031,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Tree_257_0_16, 85, G__get_linked_tagnum(&G__G__TreeLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TNtuple::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Tree_257_0_17, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TNtuple::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Tree_257_0_18, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TNtuple::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Tree_257_0_19, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TNtuple::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__TreeLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (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__G__Tree_257_0_23, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Tree_257_0_24, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TNtuple::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Tree_257_0_25, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TNtuple::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Tree_257_0_26, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TNtuple::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Tree_257_0_27, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TNtuple::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TNtuple", 842, G__G__Tree_257_0_28, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTQueryResult(void) {
   /* TQueryResult */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__TreeLN_TQueryResult));
   G__memfunc_setup("TQueryResult",1257,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__TreeLN_TQueryResult), -1, 0, 6, 1, 2, 0, 
"i - 'Int_t' 0 - seqnum C - - 10 - opt "
"U 'TList' - 0 - inlist n - 'Long64_t' 0 - entries "
"n - 'Long64_t' 0 - first C - - 10 - selec", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddInput",793,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 0, "U 'TObject' - 0 - obj", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddLogLine",947,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 0, "C - - 10 - logline", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CloneInfo",893,(G__InterfaceMethod) NULL, 85, G__get_linked_tagnum(&G__G__TreeLN_TQueryResult), -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("RecordEnd",886,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 2, 1, 2, 0, 
"i 'TQueryResult::EQueryStatus' - 0 - status U 'TList' - 0 '0' outlist", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SaveSelector",1232,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 0, "C - - 10 - selec", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetArchived",1106,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 0, "C - - 10 - archfile", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetFinalized",1218,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetInputList",1240,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 2, 1, 2, 0, 
"U 'TList' - 0 - in g - 'Bool_t' 0 'kTRUE' adopt", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetOutputList",1369,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 2, 1, 2, 0, 
"U 'TList' - 0 - out g - 'Bool_t' 0 'kTRUE' adopt", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetProcessInfo",1431,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 5, 1, 2, 0, 
"n - 'Long64_t' 0 - ent f - 'Float_t' 0 '0.' cpu "
"n - 'Long64_t' 0 '-1' siz f - 'Float_t' 0 '0.' inittime "
"f - 'Float_t' 0 '0.' proctime", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("TQueryResult",1257,G__G__Tree_261_0_12, 105, G__get_linked_tagnum(&G__G__TreeLN_TQueryResult), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Browse",626,G__G__Tree_261_0_13, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TBrowser' - 0 '0' b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetSeqNum",889,G__G__Tree_261_0_14, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetStatus",932,G__G__Tree_261_0_15, 105, G__get_linked_tagnum(&G__G__TreeLN_TQueryResultcLcLEQueryStatus), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetStartTime",1213,G__G__Tree_261_0_16, 117, G__get_linked_tagnum(&G__G__TreeLN_TDatime), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetEndTime",966,G__G__Tree_261_0_17, 117, G__get_linked_tagnum(&G__G__TreeLN_TDatime), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetOptions",1036,G__G__Tree_261_0_18, 67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetInputList",1228,G__G__Tree_261_0_19, 85, G__get_linked_tagnum(&G__G__TreeLN_TList), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetInputObject",1415,G__G__Tree_261_0_20, 85, G__get_linked_tagnum(&G__G__TreeLN_TObject), -1, 0, 1, 1, 1, 8, "C - - 10 - classname", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetEntries",1018,G__G__Tree_261_0_21, 110, -1, G__defined_typename("Long64_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetFirst",808,G__G__Tree_261_0_22, 110, -1, G__defined_typename("Long64_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetBytes",807,G__G__Tree_261_0_23, 110, -1, G__defined_typename("Long64_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetUsedCPU",921,G__G__Tree_261_0_24, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetLogFile",962,G__G__Tree_261_0_25, 85, G__get_linked_tagnum(&G__G__TreeLN_TMacro), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetSelecHdr",1066,G__G__Tree_261_0_26, 85, G__get_linked_tagnum(&G__G__TreeLN_TMacro), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetSelecImp",1074,G__G__Tree_261_0_27, 85, G__get_linked_tagnum(&G__G__TreeLN_TMacro), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetLibList",979,G__G__Tree_261_0_28, 67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetParList",991,G__G__Tree_261_0_29, 67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetOutputList",1357,G__G__Tree_261_0_30, 85, G__get_linked_tagnum(&G__G__TreeLN_TList), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetResultFile",1311,G__G__Tree_261_0_31, 67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetInitTime",1091,G__G__Tree_261_0_32, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetProcTime",1091,G__G__Tree_261_0_33, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetNumWrks",1015,G__G__Tree_261_0_34, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsArchived",994,G__G__Tree_261_0_35, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsDone",578,G__G__Tree_261_0_36, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("IsDraw",586,G__G__Tree_261_0_37, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsFinalized",1106,G__G__Tree_261_0_38, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Matches",709,G__G__Tree_261_0_39, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "C - - 10 - ref", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Print",525,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "C - 'Option_t' 10 '\"\"' opt", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Tree_261_0_41, 85, G__get_linked_tagnum(&G__G__TreeLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TQueryResult::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Tree_261_0_42, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TQueryResult::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Tree_261_0_43, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TQueryResult::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Tree_261_0_44, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TQueryResult::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__TreeLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (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__G__Tree_261_0_48, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Tree_261_0_49, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TQueryResult::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Tree_261_0_50, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TQueryResult::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Tree_261_0_51, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TQueryResult::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Tree_261_0_52, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TQueryResult::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("TQueryResult", 1257, G__G__Tree_261_0_53, (int) ('i'), G__get_linked_tagnum(&G__G__TreeLN_TQueryResult), -1, 0, 1, 1, 1, 0, "u 'TQueryResult' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~TQueryResult", 1383, G__G__Tree_261_0_54, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__G__Tree_261_0_55, (int) ('u'), G__get_linked_tagnum(&G__G__TreeLN_TQueryResult), -1, 1, 1, 1, 1, 0, "u 'TQueryResult' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTSelectorList(void) {
   /* TSelectorList */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__TreeLN_TSelectorList));
   G__memfunc_setup("UnsetDirectory",1476,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 4, 0, "U 'TObject' - 0 - obj", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CheckDuplicateName",1786,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 4, 0, "U 'TObject' - 0 - obj", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TSelectorList",1329,G__G__Tree_269_0_3, 105, G__get_linked_tagnum(&G__G__TreeLN_TSelectorList), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddFirst",785,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TObject' - 0 - obj", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("AddFirst",785,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"U 'TObject' - 0 - obj C - 'Option_t' 10 - opt", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("AddLast",669,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TObject' - 0 - obj", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("AddLast",669,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"U 'TObject' - 0 - obj C - 'Option_t' 10 - opt", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("AddAt",446,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"U 'TObject' - 0 - obj i - 'Int_t' 0 - idx", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("AddAfter",763,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"U 'TObject' - 10 - after U 'TObject' - 0 - obj", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("AddAfter",763,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"U 'TObjLink' - 0 - after U 'TObject' - 0 - obj", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("AddBefore",860,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"U 'TObject' - 10 - before U 'TObject' - 0 - obj", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("AddBefore",860,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"U 'TObjLink' - 0 - before U 'TObject' - 0 - obj", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Tree_269_0_13, 85, G__get_linked_tagnum(&G__G__TreeLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TSelectorList::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Tree_269_0_14, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TSelectorList::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Tree_269_0_15, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TSelectorList::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Tree_269_0_16, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TSelectorList::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__TreeLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (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__G__Tree_269_0_20, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Tree_269_0_21, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TSelectorList::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Tree_269_0_22, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TSelectorList::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Tree_269_0_23, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TSelectorList::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Tree_269_0_24, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TSelectorList::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TSelectorList", 1455, G__G__Tree_269_0_25, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTSelectorCint(void) {
   /* TSelectorCint */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__TreeLN_TSelectorCint));
   G__memfunc_setup("SetFuncProto",1228,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 5, 1, 4, 0, 
"Y - 'CallFunc_t' 0 - cf Y - 'ClassInfo_t' 0 - cl "
"C - - 10 - fname C - - 10 - argtype "
"g - 'Bool_t' 0 'kTRUE' required", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TSelectorCint",1315,G__G__Tree_276_0_2, 105, G__get_linked_tagnum(&G__G__TreeLN_TSelectorCint), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Build",496,G__G__Tree_276_0_3, 121, -1, -1, 0, 3, 1, 1, 0, 
"U 'TSelector' - 0 - iselector Y - 'ClassInfo_t' 0 - cl "
"g - 'Bool_t' 0 'kTRUE' isowner", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Version",742,(G__InterfaceMethod) NULL,105, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Init",404,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TTree' - 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Begin",485,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TTree' - 0 - tree", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SlaveBegin",992,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TTree' - 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Notify",633,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ProcessCut",1035,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "n - 'Long64_t' 0 - entry", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ProcessFill",1126,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "n - 'Long64_t' 0 - entry", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Process",735,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "n - 'Long64_t' 0 - entry", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetOption",933,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetObject",899,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TObject' - 0 - obj", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetInputList",1240,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TList' - 0 - input", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetOutputList",1357,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__TreeLN_TList), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SlaveTerminate",1444,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Terminate",937,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetAbort",792,(G__InterfaceMethod) NULL,105, G__get_linked_tagnum(&G__G__TreeLN_TSelectorcLcLEAbort), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetStatus",932,(G__InterfaceMethod) NULL,110, -1, G__defined_typename("Long64_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetInterpretedClass",1948,G__G__Tree_276_0_20, 85, G__get_linked_tagnum(&G__G__TreeLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetInterpretedSelector",2279,G__G__Tree_276_0_21, 85, G__get_linked_tagnum(&G__G__TreeLN_TSelector), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Tree_276_0_22, 85, G__get_linked_tagnum(&G__G__TreeLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TSelectorCint::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Tree_276_0_23, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TSelectorCint::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Tree_276_0_24, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TSelectorCint::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Tree_276_0_25, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TSelectorCint::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__TreeLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (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__G__Tree_276_0_29, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Tree_276_0_30, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TSelectorCint::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Tree_276_0_31, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TSelectorCint::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Tree_276_0_32, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TSelectorCint::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Tree_276_0_33, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TSelectorCint::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TSelectorCint", 1441, G__G__Tree_276_0_34, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTSelectorScalar(void) {
   /* TSelectorScalar */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__TreeLN_TSelectorScalar));
   G__memfunc_setup("TSelectorScalar",1515,G__G__Tree_277_0_1, 105, G__get_linked_tagnum(&G__G__TreeLN_TSelectorScalar), -1, 0, 2, 1, 1, 0, 
"C - - 10 '\"\"' name n - 'Long64_t' 0 '0' val", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Inc",282,G__G__Tree_277_0_2, 121, -1, -1, 0, 1, 1, 1, 0, "l - 'Long_t' 0 '1' n", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Merge",496,G__G__Tree_277_0_3, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "U 'TCollection' - 0 - list", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Tree_277_0_4, 85, G__get_linked_tagnum(&G__G__TreeLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TSelectorScalar::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Tree_277_0_5, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TSelectorScalar::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Tree_277_0_6, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TSelectorScalar::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Tree_277_0_7, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TSelectorScalar::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__TreeLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (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__G__Tree_277_0_11, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Tree_277_0_12, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TSelectorScalar::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Tree_277_0_13, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TSelectorScalar::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Tree_277_0_14, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TSelectorScalar::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Tree_277_0_15, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TSelectorScalar::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("TSelectorScalar", 1515, G__G__Tree_277_0_16, (int) ('i'), G__get_linked_tagnum(&G__G__TreeLN_TSelectorScalar), -1, 0, 1, 1, 1, 0, "u 'TSelectorScalar' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~TSelectorScalar", 1641, G__G__Tree_277_0_17, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__G__Tree_277_0_18, (int) ('u'), G__get_linked_tagnum(&G__G__TreeLN_TSelectorScalar), -1, 1, 1, 1, 1, 0, "u 'TSelectorScalar' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTTreeCache(void) {
   /* TTreeCache */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__TreeLN_TTreeCache));
   G__memfunc_setup("TTreeCache",952,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__TreeLN_TTreeCache), -1, 0, 1, 1, 4, 0, "u 'TTreeCache' - 11 - -", "this class cannot be copied", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__TreeLN_TTreeCache), -1, 1, 1, 1, 4, 0, "u 'TTreeCache' - 11 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TTreeCache",952,G__G__Tree_280_0_3, 105, G__get_linked_tagnum(&G__G__TreeLN_TTreeCache), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TTreeCache",952,G__G__Tree_280_0_4, 105, G__get_linked_tagnum(&G__G__TreeLN_TTreeCache), -1, 0, 2, 1, 1, 0, 
"U 'TTree' - 0 - tree i - 'Int_t' 0 '0' buffersize", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddBranch",855,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"U 'TBranch' - 0 - b g - 'Bool_t' 0 'kFALSE' subbranches", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("AddBranch",855,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"C - - 10 - branch g - 'Bool_t' 0 'kFALSE' subbranches", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetEfficiency",1301,G__G__Tree_280_0_7, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetEfficiencyRel",1592,G__G__Tree_280_0_8, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetLearnEntries",1516,G__G__Tree_280_0_9, 105, -1, G__defined_typename("Int_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Int_t (*)())(&TTreeCache::GetLearnEntries) ), 0);
   G__memfunc_setup("FillBuffer",993,G__G__Tree_280_0_10, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetOwner",811,G__G__Tree_280_0_11, 85, G__get_linked_tagnum(&G__G__TreeLN_TTree), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetTree",688,G__G__Tree_280_0_12, 85, G__get_linked_tagnum(&G__G__TreeLN_TTree), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsLearning",1004,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Print",525,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ReadBuffer",982,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 3, 1, 1, 0, 
"C - - 0 - buf n - 'Long64_t' 0 - pos "
"i - 'Int_t' 0 - len", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ResetCache",983,G__G__Tree_280_0_16, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetEntryRange",1323,G__G__Tree_280_0_17, 121, -1, -1, 0, 2, 1, 1, 0, 
"n - 'Long64_t' 0 - emin n - 'Long64_t' 0 - emax", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetLearnEntries",1528,G__G__Tree_280_0_18, 121, -1, -1, 0, 1, 3, 1, 0, "i - 'Int_t' 0 '10' n", (char*)NULL, (void*) G__func2void( (void (*)(Int_t))(&TTreeCache::SetLearnEntries) ), 0);
   G__memfunc_setup("StartLearningPhase",1839,G__G__Tree_280_0_19, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("StopLearningPhase",1735,G__G__Tree_280_0_20, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("UpdateBranches",1417,G__G__Tree_280_0_21, 121, -1, -1, 0, 2, 1, 1, 0, 
"U 'TTree' - 0 - tree g - 'Bool_t' 0 'kFALSE' owner", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Tree_280_0_22, 85, G__get_linked_tagnum(&G__G__TreeLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TTreeCache::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Tree_280_0_23, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TTreeCache::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Tree_280_0_24, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TTreeCache::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Tree_280_0_25, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TTreeCache::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__TreeLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (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__G__Tree_280_0_29, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Tree_280_0_30, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TTreeCache::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Tree_280_0_31, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TTreeCache::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Tree_280_0_32, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TTreeCache::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Tree_280_0_33, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TTreeCache::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TTreeCache", 1078, G__G__Tree_280_0_34, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTTreeCacheUnzip(void) {
   /* TTreeCacheUnzip */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__TreeLN_TTreeCacheUnzip));
   G__memfunc_setup("TTreeCacheUnzip",1486,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__TreeLN_TTreeCacheUnzip), -1, 0, 1, 1, 4, 0, "u 'TTreeCacheUnzip' - 11 - -", "this class cannot be copied", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__TreeLN_TTreeCacheUnzip), -1, 1, 1, 1, 4, 0, "u 'TTreeCacheUnzip' - 11 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Init",404,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("StartThreadUnzip",1660,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 4, 0, "i - 'Int_t' 0 - nthreads", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("StopThreadUnzip",1556,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TTreeCacheUnzip",1486,G__G__Tree_284_0_6, 105, G__get_linked_tagnum(&G__G__TreeLN_TTreeCacheUnzip), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TTreeCacheUnzip",1486,G__G__Tree_284_0_7, 105, G__get_linked_tagnum(&G__G__TreeLN_TTreeCacheUnzip), -1, 0, 2, 1, 1, 0, 
"U 'TTree' - 0 - tree i - 'Int_t' 0 '0' buffersize", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddBranch",855,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"U 'TBranch' - 0 - b g - 'Bool_t' 0 'kFALSE' subbranches", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("AddBranch",855,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"C - - 10 - branch g - 'Bool_t' 0 'kFALSE' subbranches", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("FillBuffer",993,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ReadBufferExt",1287,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 4, 1, 1, 0, 
"C - - 0 - buf n - 'Long64_t' 0 - pos "
"i - 'Int_t' 0 - len i - 'Int_t' 1 - loc", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetEntryRange",1323,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"n - 'Long64_t' 0 - emin n - 'Long64_t' 0 - emax", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StopLearningPhase",1735,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("UpdateBranches",1417,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"U 'TTree' - 0 - tree g - 'Bool_t' 0 'kFALSE' owner", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetParallelUnzip",1635,G__G__Tree_284_0_15, 105, G__get_linked_tagnum(&G__G__TreeLN_TTreeCacheUnzipcLcLEParUnzipMode), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TTreeCacheUnzip::EParUnzipMode (*)())(&TTreeCacheUnzip::GetParallelUnzip) ), 0);
   G__memfunc_setup("IsParallelUnzip",1535,G__G__Tree_284_0_16, 103, -1, G__defined_typename("Bool_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Bool_t (*)())(&TTreeCacheUnzip::IsParallelUnzip) ), 0);
   G__memfunc_setup("SetParallelUnzip",1647,G__G__Tree_284_0_17, 105, -1, G__defined_typename("Int_t"), 0, 1, 3, 1, 0, "i 'TTreeCacheUnzip::EParUnzipMode' - 0 'TTreeCacheUnzip::kEnable' option", (char*)NULL, (void*) G__func2void( (Int_t (*)(TTreeCacheUnzip::EParUnzipMode))(&TTreeCacheUnzip::SetParallelUnzip) ), 0);
   G__memfunc_setup("IsActiveThread",1392,G__G__Tree_284_0_18, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsQueueEmpty",1232,G__G__Tree_284_0_19, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("WaitUnzipStartSignal",2071,G__G__Tree_284_0_20, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SendUnzipStartSignal",2060,G__G__Tree_284_0_21, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - broadcast", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetRecordHeader",1480,G__G__Tree_284_0_22, 105, -1, G__defined_typename("Int_t"), 0, 5, 1, 1, 0, 
"C - - 0 - buf i - 'Int_t' 0 - maxbytes "
"i - 'Int_t' 1 - nbytes i - 'Int_t' 1 - objlen "
"i - 'Int_t' 1 - keylen", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ResetCache",983,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetUnzipBuffer",1424,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 4, 1, 1, 0, 
"C - - 2 - buf n - 'Long64_t' 0 - pos "
"i - 'Int_t' 0 - len G - 'Bool_t' 0 - free", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetUnzipBufferSize",1847,G__G__Tree_284_0_25, 121, -1, -1, 0, 1, 1, 1, 0, "n - 'Long64_t' 0 - bufferSize", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetUnzipRelBufferSize",2138,G__G__Tree_284_0_26, 121, -1, -1, 0, 1, 3, 1, 0, "f - 'Float_t' 0 - relbufferSize", (char*)NULL, (void*) G__func2void( (void (*)(Float_t))(&TTreeCacheUnzip::SetUnzipRelBufferSize) ), 0);
   G__memfunc_setup("UnzipBuffer",1136,G__G__Tree_284_0_27, 105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 0, 
"C - - 2 - dest C - - 0 - src", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("UnzipCache",1002,G__G__Tree_284_0_28, 105, -1, G__defined_typename("Int_t"), 0, 3, 1, 1, 0, 
"i - 'Int_t' 1 - startindex i - 'Int_t' 1 - locbuffsz "
"C - - 1 - locbuff", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetNUnzip",900,G__G__Tree_284_0_29, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetNFound",874,G__G__Tree_284_0_30, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetNMissed",979,G__G__Tree_284_0_31, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Print",525,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("UnzipLoop",944,G__G__Tree_284_0_33, 89, -1, -1, 0, 1, 3, 1, 0, "Y - - 0 - arg", (char*)NULL, (void*) G__func2void( (void* (*)(void*))(&TTreeCacheUnzip::UnzipLoop) ), 0);
   G__memfunc_setup("Class",502,G__G__Tree_284_0_34, 85, G__get_linked_tagnum(&G__G__TreeLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TTreeCacheUnzip::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Tree_284_0_35, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TTreeCacheUnzip::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Tree_284_0_36, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TTreeCacheUnzip::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Tree_284_0_37, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TTreeCacheUnzip::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__TreeLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (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__G__Tree_284_0_41, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Tree_284_0_42, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TTreeCacheUnzip::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Tree_284_0_43, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TTreeCacheUnzip::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Tree_284_0_44, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TTreeCacheUnzip::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Tree_284_0_45, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TTreeCacheUnzip::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TTreeCacheUnzip", 1612, G__G__Tree_284_0_46, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTTreeResult(void) {
   /* TTreeResult */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__TreeLN_TTreeResult));
   G__memfunc_setup("IsValid",684,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 4, 0, "i - 'Int_t' 0 - field", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddField",749,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 2, 1, 4, 0, 
"i - 'Int_t' 0 - field C - - 10 - fieldname", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddRow",577,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "U 'TSQLRow' - 0 - row", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TTreeResult",1123,G__G__Tree_294_0_4, 105, G__get_linked_tagnum(&G__G__TreeLN_TTreeResult), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TTreeResult",1123,G__G__Tree_294_0_5, 105, G__get_linked_tagnum(&G__G__TreeLN_TTreeResult), -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - nfields", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Close",502,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetFieldCount",1293,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetFieldName",1157,(G__InterfaceMethod) NULL,67, -1, -1, 0, 1, 1, 1, 1, "i - 'Int_t' 0 - field", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetRows",715,G__G__Tree_294_0_9, 85, G__get_linked_tagnum(&G__G__TreeLN_TObjArray), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Next",415,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__TreeLN_TSQLRow), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Tree_294_0_11, 85, G__get_linked_tagnum(&G__G__TreeLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TTreeResult::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Tree_294_0_12, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TTreeResult::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Tree_294_0_13, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TTreeResult::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Tree_294_0_14, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TTreeResult::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__TreeLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (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__G__Tree_294_0_18, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Tree_294_0_19, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TTreeResult::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Tree_294_0_20, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TTreeResult::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Tree_294_0_21, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TTreeResult::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Tree_294_0_22, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TTreeResult::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("TTreeResult", 1123, G__G__Tree_294_0_23, (int) ('i'), G__get_linked_tagnum(&G__G__TreeLN_TTreeResult), -1, 0, 1, 1, 1, 0, "u 'TTreeResult' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~TTreeResult", 1249, G__G__Tree_294_0_24, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__G__Tree_294_0_25, (int) ('u'), G__get_linked_tagnum(&G__G__TreeLN_TTreeResult), -1, 1, 1, 1, 1, 0, "u 'TTreeResult' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTTreeRow(void) {
   /* TTreeRow */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__TreeLN_TTreeRow));
   G__memfunc_setup("TTreeRow",796,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__TreeLN_TTreeRow), -1, 0, 1, 1, 4, 0, "U 'TSQLRow' - 0 - original", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsValid",684,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 4, 0, "i - 'Int_t' 0 - field", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TTreeRow",796,G__G__Tree_295_0_3, 105, G__get_linked_tagnum(&G__G__TreeLN_TTreeRow), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TTreeRow",796,G__G__Tree_295_0_4, 105, G__get_linked_tagnum(&G__G__TreeLN_TTreeRow), -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - nfields", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TTreeRow",796,G__G__Tree_295_0_5, 105, G__get_linked_tagnum(&G__G__TreeLN_TTreeRow), -1, 0, 3, 1, 1, 0, 
"i - 'Int_t' 0 - nfields I - 'Int_t' 10 - fields "
"C - - 10 - row", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Close",502,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetFieldLength",1382,(G__InterfaceMethod) NULL,107, -1, G__defined_typename("ULong_t"), 0, 1, 1, 1, 0, "i - 'Int_t' 0 - field", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetField",772,(G__InterfaceMethod) NULL,67, -1, -1, 0, 1, 1, 1, 1, "i - 'Int_t' 0 - field", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetRow",612,G__G__Tree_295_0_9, 121, -1, -1, 0, 2, 1, 1, 0, 
"I - 'Int_t' 10 - fields C - - 10 - row", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Tree_295_0_10, 85, G__get_linked_tagnum(&G__G__TreeLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TTreeRow::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Tree_295_0_11, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TTreeRow::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Tree_295_0_12, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TTreeRow::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Tree_295_0_13, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TTreeRow::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__TreeLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (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__G__Tree_295_0_17, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Tree_295_0_18, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TTreeRow::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Tree_295_0_19, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TTreeRow::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Tree_295_0_20, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TTreeRow::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Tree_295_0_21, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TTreeRow::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("TTreeRow", 796, G__G__Tree_295_0_22, (int) ('i'), G__get_linked_tagnum(&G__G__TreeLN_TTreeRow), -1, 0, 1, 1, 1, 0, "u 'TTreeRow' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~TTreeRow", 922, G__G__Tree_295_0_23, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__G__Tree_295_0_24, (int) ('u'), G__get_linked_tagnum(&G__G__TreeLN_TTreeRow), -1, 1, 1, 1, 1, 0, "u 'TTreeRow' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTTreeSQL(void) {
   /* TTreeSQL */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__TreeLN_TTreeSQL));
   G__memfunc_setup("CheckBasket",1080,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 0, "U 'TBranch' - 0 - tb", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CheckBranch",1068,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 2, 0, "U 'TBranch' - 0 - tb", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CheckTable",966,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 2, 8, "u 'TString' - 11 - table", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CreateBranches",1402,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__TreeLN_TString), -1, 0, 1, 1, 2, 0, "U 'TSQLResult' - 0 - rs", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetColumnIndice",1498,(G__InterfaceMethod) NULL, 85, G__get_linked_tagnum(&G__G__TreeLN_vectorlEintcOallocatorlEintgRsPgR), G__defined_typename("vector<Int_t>"), 0, 1, 1, 2, 0, "U 'TBranch' - 0 - branch", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Init",404,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ResetQuery",1049,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ConvertTypeName",1540,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__TreeLN_TString), -1, 0, 1, 1, 2, 0, "u 'TString' - 11 - typeName", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CreateBranch",1186,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 2, 1, 2, 0, 
"u 'TString' - 11 - branchName u 'TString' - 11 - typeName", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("CreateTable",1084,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 2, 0, "u 'TString' - 11 - table", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CreateBasket",1198,(G__InterfaceMethod) NULL, 85, G__get_linked_tagnum(&G__G__TreeLN_TBasket), -1, 0, 1, 1, 2, 0, "U 'TBranch' - 0 - br", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("BranchImp",884,(G__InterfaceMethod) NULL, 85, G__get_linked_tagnum(&G__G__TreeLN_TBranch), -1, 0, 6, 1, 2, 0, 
"C - - 10 - branchname C - - 10 - classname "
"U 'TClass' - 0 - ptrClass Y - - 0 - addobj "
"i - 'Int_t' 0 - bufsize i - 'Int_t' 0 - splitlevel", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("BranchImp",884,(G__InterfaceMethod) NULL, 85, G__get_linked_tagnum(&G__G__TreeLN_TBranch), -1, 0, 5, 1, 2, 0, 
"C - - 10 - branchname U 'TClass' - 0 - ptrClass "
"Y - - 0 - addobj i - 'Int_t' 0 - bufsize "
"i - 'Int_t' 0 - splitlevel", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("TTreeSQL",724,G__G__Tree_297_0_14, 105, G__get_linked_tagnum(&G__G__TreeLN_TTreeSQL), -1, 0, 3, 1, 1, 0, 
"U 'TSQLServer' - 0 - server u 'TString' - 0 - DB "
"u 'TString' - 11 - table", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Branch",590,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 4, 1, 1, 0, 
"U 'TCollection' - 0 - list i - 'Int_t' 0 '32000' bufsize "
"i - 'Int_t' 0 '99' splitlevel C - - 10 '\"\"' name", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Branch",590,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 3, 1, 1, 0, 
"U 'TList' - 0 - list i - 'Int_t' 0 '32000' bufsize "
"i - 'Int_t' 0 '99' splitlevel", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Branch",590,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 3, 1, 1, 0, 
"C - - 10 - folder i - 'Int_t' 0 '32000' bufsize "
"i - 'Int_t' 0 '99' splitlevel", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Bronch",604,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__TreeLN_TBranch), -1, 0, 5, 1, 1, 0, 
"C - - 10 - name C - - 10 - classname "
"Y - - 0 - addobj i - 'Int_t' 0 '32000' bufsize "
"i - 'Int_t' 0 '99' splitlevel", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("BranchOld",877,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__TreeLN_TBranch), -1, 0, 5, 1, 1, 0, 
"C - - 10 - name C - - 10 - classname "
"Y - - 0 - addobj i - 'Int_t' 0 '32000' bufsize "
"i - 'Int_t' 0 '1' splitlevel", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Branch",590,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__TreeLN_TBranch), -1, 0, 4, 1, 1, 0, 
"C - - 10 - name Y - - 0 - address "
"C - - 10 - leaflist i - 'Int_t' 0 - bufsize", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Fill",391,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetEntry",818,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 0, 
"n - 'Long64_t' 0 '0' entry i - 'Int_t' 0 '0' getall", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetEntries",1018,(G__InterfaceMethod) NULL,110, -1, G__defined_typename("Long64_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetEntries",1018,(G__InterfaceMethod) NULL,110, -1, G__defined_typename("Long64_t"), 0, 1, 1, 1, 0, "C - - 10 - sel", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetEntriesFast",1416,(G__InterfaceMethod) NULL,110, -1, G__defined_typename("Long64_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetTableName",1161,G__G__Tree_297_0_26, 117, G__get_linked_tagnum(&G__G__TreeLN_TString), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("LoadTree",784,(G__InterfaceMethod) NULL,110, -1, G__defined_typename("Long64_t"), 0, 1, 1, 1, 0, "n - 'Long64_t' 0 - entry", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("PrepEntry",937,G__G__Tree_297_0_28, 110, -1, G__defined_typename("Long64_t"), 0, 1, 1, 1, 0, "n - 'Long64_t' 0 - entry", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Refresh",719,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Tree_297_0_30, 85, G__get_linked_tagnum(&G__G__TreeLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TTreeSQL::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Tree_297_0_31, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TTreeSQL::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Tree_297_0_32, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TTreeSQL::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Tree_297_0_33, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TTreeSQL::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__TreeLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (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__G__Tree_297_0_37, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Tree_297_0_38, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TTreeSQL::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Tree_297_0_39, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TTreeSQL::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Tree_297_0_40, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TTreeSQL::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Tree_297_0_41, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TTreeSQL::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TTreeSQL", 850, G__G__Tree_297_0_42, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}


/*********************************************************
* Member function information setup
*********************************************************/
extern "C" void G__cpp_setup_memfuncG__Tree() {
}

/*********************************************************
* 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() {
}

static void G__cpp_setup_global2() {
}

static void G__cpp_setup_global3() {

   G__resetglobalenv();
}
extern "C" void G__cpp_setup_globalG__Tree() {
  G__cpp_setup_global0();
  G__cpp_setup_global1();
  G__cpp_setup_global2();
  G__cpp_setup_global3();
}

/*********************************************************
* 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() {
   G__memfunc_setup("operator+", 919, G__G__Tree__0_674, 117, G__get_linked_tagnum(&G__G__TreeLN_TCut), -1, 0, 2, 1, 1, 0, 
"u 'TCut' - 11 - lhs C - - 10 - rhs", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator+", 919, G__G__Tree__0_675, 117, G__get_linked_tagnum(&G__G__TreeLN_TCut), -1, 0, 2, 1, 1, 0, 
"C - - 10 - lhs u 'TCut' - 11 - rhs", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator+", 919, G__G__Tree__0_676, 117, G__get_linked_tagnum(&G__G__TreeLN_TCut), -1, 0, 2, 1, 1, 0, 
"u 'TCut' - 11 - lhs u 'TCut' - 11 - rhs", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator*", 918, G__G__Tree__0_677, 117, G__get_linked_tagnum(&G__G__TreeLN_TCut), -1, 0, 2, 1, 1, 0, 
"u 'TCut' - 11 - lhs C - - 10 - rhs", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator*", 918, G__G__Tree__0_678, 117, G__get_linked_tagnum(&G__G__TreeLN_TCut), -1, 0, 2, 1, 1, 0, 
"C - - 10 - lhs u 'TCut' - 11 - rhs", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator*", 918, G__G__Tree__0_679, 117, G__get_linked_tagnum(&G__G__TreeLN_TCut), -1, 0, 2, 1, 1, 0, 
"u 'TCut' - 11 - lhs u 'TCut' - 11 - rhs", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator&&", 952, G__G__Tree__0_680, 117, G__get_linked_tagnum(&G__G__TreeLN_TCut), -1, 0, 2, 1, 1, 0, 
"u 'TCut' - 11 - lhs C - - 10 - rhs", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator&&", 952, G__G__Tree__0_681, 117, G__get_linked_tagnum(&G__G__TreeLN_TCut), -1, 0, 2, 1, 1, 0, 
"C - - 10 - lhs u 'TCut' - 11 - rhs", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator&&", 952, G__G__Tree__0_682, 117, G__get_linked_tagnum(&G__G__TreeLN_TCut), -1, 0, 2, 1, 1, 0, 
"u 'TCut' - 11 - lhs u 'TCut' - 11 - rhs", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator||", 1124, G__G__Tree__0_683, 117, G__get_linked_tagnum(&G__G__TreeLN_TCut), -1, 0, 2, 1, 1, 0, 
"u 'TCut' - 11 - lhs C - - 10 - rhs", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator||", 1124, G__G__Tree__0_684, 117, G__get_linked_tagnum(&G__G__TreeLN_TCut), -1, 0, 2, 1, 1, 0, 
"C - - 10 - lhs u 'TCut' - 11 - rhs", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator||", 1124, G__G__Tree__0_685, 117, G__get_linked_tagnum(&G__G__TreeLN_TCut), -1, 0, 2, 1, 1, 0, 
"u 'TCut' - 11 - lhs u 'TCut' - 11 - rhs", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator!", 909, G__G__Tree__0_686, 117, G__get_linked_tagnum(&G__G__TreeLN_TCut), -1, 0, 1, 1, 1, 0, "u 'TCut' - 11 - rhs", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator+", 919, G__G__Tree__0_688, 117, G__get_linked_tagnum(&G__G__TreeLN_TEventList), -1, 0, 2, 1, 1, 0, 
"u 'TEventList' - 11 - list1 u 'TEventList' - 11 - list2", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator-", 921, G__G__Tree__0_689, 117, G__get_linked_tagnum(&G__G__TreeLN_TEventList), -1, 0, 2, 1, 1, 0, 
"u 'TEventList' - 11 - list1 u 'TEventList' - 11 - list2", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator*", 918, G__G__Tree__0_690, 117, G__get_linked_tagnum(&G__G__TreeLN_TEventList), -1, 0, 2, 1, 1, 0, 
"u 'TEventList' - 11 - list1 u 'TEventList' - 11 - list2", (char*) NULL
, (void*) NULL, 0);
}

static void G__cpp_setup_func7() {

   G__resetifuncposition();
}

extern "C" void G__cpp_setup_funcG__Tree() {
  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();
}

/*********************************************************
* Class,struct,union,enum tag information setup
*********************************************************/
/* Setup class/struct taginfo */
G__linked_taginfo G__G__TreeLN_TClass = { "TClass" , 99 , -1 };
G__linked_taginfo G__G__TreeLN_TBuffer = { "TBuffer" , 99 , -1 };
G__linked_taginfo G__G__TreeLN_TDirectory = { "TDirectory" , 99 , -1 };
G__linked_taginfo G__G__TreeLN_TMemberInspector = { "TMemberInspector" , 99 , -1 };
G__linked_taginfo G__G__TreeLN_TObject = { "TObject" , 99 , -1 };
G__linked_taginfo G__G__TreeLN_TNamed = { "TNamed" , 99 , -1 };
G__linked_taginfo G__G__TreeLN_TString = { "TString" , 99 , -1 };
G__linked_taginfo G__G__TreeLN_TMemberStreamer = { "TMemberStreamer" , 99 , -1 };
G__linked_taginfo G__G__TreeLN_TVirtualCollectionProxy = { "TVirtualCollectionProxy" , 99 , -1 };
G__linked_taginfo G__G__TreeLN_basic_istreamlEcharcOchar_traitslEchargRsPgR = { "basic_istream<char,char_traits<char> >" , 99 , -1 };
G__linked_taginfo G__G__TreeLN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR = { "vector<ROOT::TSchemaHelper,allocator<ROOT::TSchemaHelper> >" , 99 , -1 };
G__linked_taginfo G__G__TreeLN_reverse_iteratorlEvectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgRcLcLiteratorgR = { "reverse_iterator<vector<ROOT::TSchemaHelper,allocator<ROOT::TSchemaHelper> >::iterator>" , 99 , -1 };
G__linked_taginfo G__G__TreeLN_TList = { "TList" , 99 , -1 };
G__linked_taginfo G__G__TreeLN_TBrowser = { "TBrowser" , 99 , -1 };
G__linked_taginfo G__G__TreeLN_TObjArray = { "TObjArray" , 99 , -1 };
G__linked_taginfo G__G__TreeLN_TMethod = { "TMethod" , 99 , -1 };
G__linked_taginfo G__G__TreeLN_TStreamerElement = { "TStreamerElement" , 99 , -1 };
G__linked_taginfo G__G__TreeLN_TClonesArray = { "TClonesArray" , 99 , -1 };
G__linked_taginfo G__G__TreeLN_TRefTable = { "TRefTable" , 99 , -1 };
G__linked_taginfo G__G__TreeLN_TVirtualArray = { "TVirtualArray" , 99 , -1 };
G__linked_taginfo G__G__TreeLN_TStreamerInfoActions = { "TStreamerInfoActions" , 110 , -1 };
G__linked_taginfo G__G__TreeLN_TStreamerInfoActionscLcLTActionSequence = { "TStreamerInfoActions::TActionSequence" , 99 , -1 };
G__linked_taginfo G__G__TreeLN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR = { "vector<TVirtualArray*,allocator<TVirtualArray*> >" , 99 , -1 };
G__linked_taginfo G__G__TreeLN_reverse_iteratorlEvectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<TVirtualArray*,allocator<TVirtualArray*> >::iterator>" , 99 , -1 };
G__linked_taginfo G__G__TreeLN_TBuffercLcLEMode = { "TBuffer::EMode" , 101 , -1 };
G__linked_taginfo G__G__TreeLN_TDatime = { "TDatime" , 99 , -1 };
G__linked_taginfo G__G__TreeLN_TFile = { "TFile" , 99 , -1 };
G__linked_taginfo G__G__TreeLN_TKey = { "TKey" , 99 , -1 };
G__linked_taginfo G__G__TreeLN_TTree = { "TTree" , 99 , -1 };
G__linked_taginfo G__G__TreeLN_TBranch = { "TBranch" , 99 , -1 };
G__linked_taginfo G__G__TreeLN_TBasket = { "TBasket" , 99 , -1 };
G__linked_taginfo G__G__TreeLN_TSQLResult = { "TSQLResult" , 99 , -1 };
G__linked_taginfo G__G__TreeLN_TSQLRow = { "TSQLRow" , 99 , -1 };
G__linked_taginfo G__G__TreeLN_TBufferSQL = { "TBufferSQL" , 99 , -1 };
G__linked_taginfo G__G__TreeLN_TBasketSQL = { "TBasketSQL" , 99 , -1 };
G__linked_taginfo G__G__TreeLN_vectorlEintcOallocatorlEintgRsPgR = { "vector<int,allocator<int> >" , 99 , -1 };
G__linked_taginfo G__G__TreeLN_vectorlEintcOallocatorlEintgRsPgRcLcLiterator = { "vector<int,allocator<int> >::iterator" , 99 , -1 };
G__linked_taginfo G__G__TreeLN_reverse_iteratorlEvectorlEintcOallocatorlEintgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<int,allocator<int> >::iterator>" , 99 , -1 };
G__linked_taginfo G__G__TreeLN_TCollection = { "TCollection" , 99 , -1 };
G__linked_taginfo G__G__TreeLN_TIterator = { "TIterator" , 99 , -1 };
G__linked_taginfo G__G__TreeLN_TSeqCollection = { "TSeqCollection" , 99 , -1 };
G__linked_taginfo G__G__TreeLN_TObjLink = { "TObjLink" , 99 , -1 };
G__linked_taginfo G__G__TreeLN_iteratorlEbidirectional_iterator_tagcOTObjectmUcOlongcOconstsPTObjectmUmUcOconstsPTObjectmUaNgR = { "iterator<bidirectional_iterator_tag,TObject*,long,const TObject**,const TObject*&>" , 115 , -1 };
G__linked_taginfo G__G__TreeLN_TBranchElement = { "TBranchElement" , 99 , -1 };
G__linked_taginfo G__G__TreeLN_TVirtualBranchBrowsable = { "TVirtualBranchBrowsable" , 99 , -1 };
G__linked_taginfo G__G__TreeLN_listlEvoidmUcOallocatorlEvoidmUgRsPgR = { "list<void*,allocator<void*> >" , 99 , -1 };
G__linked_taginfo G__G__TreeLN_TMethodBrowsable = { "TMethodBrowsable" , 99 , -1 };
G__linked_taginfo G__G__TreeLN_TNonSplitBrowsable = { "TNonSplitBrowsable" , 99 , -1 };
G__linked_taginfo G__G__TreeLN_TCollectionPropertyBrowsable = { "TCollectionPropertyBrowsable" , 99 , -1 };
G__linked_taginfo G__G__TreeLN_TCollectionMethodBrowsable = { "TCollectionMethodBrowsable" , 99 , -1 };
G__linked_taginfo G__G__TreeLN_TAttFill = { "TAttFill" , 99 , -1 };
G__linked_taginfo G__G__TreeLN_EDataType = { "EDataType" , 101 , -1 };
G__linked_taginfo G__G__TreeLN_TLeaf = { "TLeaf" , 99 , -1 };
G__linked_taginfo G__G__TreeLN_TBranchcLcLdA = { "TBranch::$" , 101 , -1 };
G__linked_taginfo G__G__TreeLN_TTreeCloner = { "TTreeCloner" , 99 , -1 };
G__linked_taginfo G__G__TreeLN_TBranchClones = { "TBranchClones" , 99 , -1 };
G__linked_taginfo G__G__TreeLN_TClassRef = { "TClassRef" , 99 , -1 };
G__linked_taginfo G__G__TreeLN_TMethodCall = { "TMethodCall" , 99 , -1 };
G__linked_taginfo G__G__TreeLN_maplEstringcOTObjArraymUcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOTObjArraymUgRsPgRsPgR = { "map<string,TObjArray*,less<string>,allocator<pair<const string,TObjArray*> > >" , 99 , -1 };
G__linked_taginfo G__G__TreeLN_TAttLine = { "TAttLine" , 99 , -1 };
G__linked_taginfo G__G__TreeLN_TAttMarker = { "TAttMarker" , 99 , -1 };
G__linked_taginfo G__G__TreeLN_TArrayD = { "TArrayD" , 99 , -1 };
G__linked_taginfo G__G__TreeLN_TArrayI = { "TArrayI" , 99 , -1 };
G__linked_taginfo G__G__TreeLN_TH1 = { "TH1" , 99 , -1 };
G__linked_taginfo G__G__TreeLN_TTreeFormula = { "TTreeFormula" , 99 , -1 };
G__linked_taginfo G__G__TreeLN_TSelector = { "TSelector" , 99 , -1 };
G__linked_taginfo G__G__TreeLN_TPrincipal = { "TPrincipal" , 99 , -1 };
G__linked_taginfo G__G__TreeLN_TVirtualIndex = { "TVirtualIndex" , 99 , -1 };
G__linked_taginfo G__G__TreeLN_TVirtualTreePlayer = { "TVirtualTreePlayer" , 99 , -1 };
G__linked_taginfo G__G__TreeLN_TEventList = { "TEventList" , 99 , -1 };
G__linked_taginfo G__G__TreeLN_TEntryList = { "TEntryList" , 99 , -1 };
G__linked_taginfo G__G__TreeLN_TFriendElement = { "TFriendElement" , 99 , -1 };
G__linked_taginfo G__G__TreeLN_TCut = { "TCut" , 99 , -1 };
G__linked_taginfo G__G__TreeLN_TBranchRef = { "TBranchRef" , 99 , -1 };
G__linked_taginfo G__G__TreeLN_TStreamerInfo = { "TStreamerInfo" , 99 , -1 };
G__linked_taginfo G__G__TreeLN_TTreecLcLELockStatusBits = { "TTree::ELockStatusBits" , 101 , -1 };
G__linked_taginfo G__G__TreeLN_TTreecLcLSetBranchAddressStatus = { "TTree::SetBranchAddressStatus" , 101 , -1 };
G__linked_taginfo G__G__TreeLN_TTreecLcLdA = { "TTree::$" , 101 , -1 };
G__linked_taginfo G__G__TreeLN_TTreeFriendLeafIter = { "TTreeFriendLeafIter" , 99 , -1 };
G__linked_taginfo G__G__TreeLN_TVirtualCollectionIterators = { "TVirtualCollectionIterators" , 99 , -1 };
G__linked_taginfo G__G__TreeLN_TVirtualCollectionPtrIterators = { "TVirtualCollectionPtrIterators" , 99 , -1 };
G__linked_taginfo G__G__TreeLN_TBranchElementcLcLdA = { "TBranchElement::$" , 101 , -1 };
G__linked_taginfo G__G__TreeLN_TBranchObject = { "TBranchObject" , 99 , -1 };
G__linked_taginfo G__G__TreeLN_TBranchObjectcLcLdA = { "TBranchObject::$" , 101 , -1 };
G__linked_taginfo G__G__TreeLN_vectorlEstringcOallocatorlEstringgRsPgR = { "vector<string,allocator<string> >" , 99 , -1 };
G__linked_taginfo G__G__TreeLN_reverse_iteratorlEvectorlEstringcOallocatorlEstringgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<string,allocator<string> >::iterator>" , 99 , -1 };
G__linked_taginfo G__G__TreeLN_TIndArray = { "TIndArray" , 99 , -1 };
G__linked_taginfo G__G__TreeLN_TBranchSTL = { "TBranchSTL" , 99 , -1 };
G__linked_taginfo G__G__TreeLN_TBufferFile = { "TBufferFile" , 99 , -1 };
G__linked_taginfo G__G__TreeLN_vectorlETStreamerInfomUcOallocatorlETStreamerInfomUgRsPgR = { "vector<TStreamerInfo*,allocator<TStreamerInfo*> >" , 99 , -1 };
G__linked_taginfo G__G__TreeLN_reverse_iteratorlEvectorlETStreamerInfomUcOallocatorlETStreamerInfomUgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<TStreamerInfo*,allocator<TStreamerInfo*> >::iterator>" , 99 , -1 };
G__linked_taginfo G__G__TreeLN_TChainElement = { "TChainElement" , 99 , -1 };
G__linked_taginfo G__G__TreeLN_TChainElementcLcLEStatusBits = { "TChainElement::EStatusBits" , 101 , -1 };
G__linked_taginfo G__G__TreeLN_TChain = { "TChain" , 99 , -1 };
G__linked_taginfo G__G__TreeLN_TChaincLcLdA = { "TChain::$" , 101 , -1 };
G__linked_taginfo G__G__TreeLN_TEntryListBlock = { "TEntryListBlock" , 99 , -1 };
G__linked_taginfo G__G__TreeLN_TEntryListBlockcLcLdA = { "TEntryListBlock::$" , 101 , -1 };
G__linked_taginfo G__G__TreeLN_TEntryListcLcLdA = { "TEntryList::$" , 101 , -1 };
G__linked_taginfo G__G__TreeLN_TEntryListFromFile = { "TEntryListFromFile" , 99 , -1 };
G__linked_taginfo G__G__TreeLN_TEntryListFromFilecLcLdA = { "TEntryListFromFile::$" , 101 , -1 };
G__linked_taginfo G__G__TreeLN_TFriendElementcLcLdA = { "TFriendElement::$" , 101 , -1 };
G__linked_taginfo G__G__TreeLN_TLeafcLcLdA = { "TLeaf::$" , 101 , -1 };
G__linked_taginfo G__G__TreeLN_TLeafB = { "TLeafB" , 99 , -1 };
G__linked_taginfo G__G__TreeLN_TLeafC = { "TLeafC" , 99 , -1 };
G__linked_taginfo G__G__TreeLN_TLeafD = { "TLeafD" , 99 , -1 };
G__linked_taginfo G__G__TreeLN_TLeafElement = { "TLeafElement" , 99 , -1 };
G__linked_taginfo G__G__TreeLN_TLeafF = { "TLeafF" , 99 , -1 };
G__linked_taginfo G__G__TreeLN_TLeafI = { "TLeafI" , 99 , -1 };
G__linked_taginfo G__G__TreeLN_TLeafL = { "TLeafL" , 99 , -1 };
G__linked_taginfo G__G__TreeLN_TLeafObject = { "TLeafObject" , 99 , -1 };
G__linked_taginfo G__G__TreeLN_TLeafObjectcLcLdA = { "TLeafObject::$" , 101 , -1 };
G__linked_taginfo G__G__TreeLN_TLeafO = { "TLeafO" , 99 , -1 };
G__linked_taginfo G__G__TreeLN_TLeafS = { "TLeafS" , 99 , -1 };
G__linked_taginfo G__G__TreeLN_TNtupleD = { "TNtupleD" , 99 , -1 };
G__linked_taginfo G__G__TreeLN_TNtuple = { "TNtuple" , 99 , -1 };
G__linked_taginfo G__G__TreeLN_TMacro = { "TMacro" , 99 , -1 };
G__linked_taginfo G__G__TreeLN_TQueryResult = { "TQueryResult" , 99 , -1 };
G__linked_taginfo G__G__TreeLN_TQueryResultcLcLEQueryStatus = { "TQueryResult::EQueryStatus" , 101 , -1 };
G__linked_taginfo G__G__TreeLN_TSelectorList = { "TSelectorList" , 99 , -1 };
G__linked_taginfo G__G__TreeLN_TSelectorcLcLEAbort = { "TSelector::EAbort" , 101 , -1 };
G__linked_taginfo G__G__TreeLN_TSelectorCint = { "TSelectorCint" , 99 , -1 };
G__linked_taginfo G__G__TreeLN_TSelectorScalar = { "TSelectorScalar" , 99 , -1 };
G__linked_taginfo G__G__TreeLN_TParameterlElongsPlonggR = { "TParameter<long long>" , 99 , -1 };
G__linked_taginfo G__G__TreeLN_TFileCacheRead = { "TFileCacheRead" , 99 , -1 };
G__linked_taginfo G__G__TreeLN_TTreeCache = { "TTreeCache" , 99 , -1 };
G__linked_taginfo G__G__TreeLN_TThread = { "TThread" , 99 , -1 };
G__linked_taginfo G__G__TreeLN_TCondition = { "TCondition" , 99 , -1 };
G__linked_taginfo G__G__TreeLN_TMutex = { "TMutex" , 99 , -1 };
G__linked_taginfo G__G__TreeLN_TTreeCacheUnzip = { "TTreeCacheUnzip" , 99 , -1 };
G__linked_taginfo G__G__TreeLN_TTreeCacheUnzipcLcLEParUnzipMode = { "TTreeCacheUnzip::EParUnzipMode" , 101 , -1 };
G__linked_taginfo G__G__TreeLN_dequelEintcOallocatorlEintgRsPgR = { "deque<int,allocator<int> >" , 99 , -1 };
G__linked_taginfo G__G__TreeLN_queuelEintcOdequelEintcOallocatorlEintgRsPgRsPgR = { "queue<int,deque<int,allocator<int> > >" , 99 , -1 };
G__linked_taginfo G__G__TreeLN_TTreeClonercLcLECloneMethod = { "TTreeCloner::ECloneMethod" , 101 , -1 };
G__linked_taginfo G__G__TreeLN_TTreeClonercLcLEClonerOptions = { "TTreeCloner::EClonerOptions" , 101 , -1 };
G__linked_taginfo G__G__TreeLN_TTreeResult = { "TTreeResult" , 99 , -1 };
G__linked_taginfo G__G__TreeLN_TTreeRow = { "TTreeRow" , 99 , -1 };
G__linked_taginfo G__G__TreeLN_TSQLServer = { "TSQLServer" , 99 , -1 };
G__linked_taginfo G__G__TreeLN_TTreeSQL = { "TTreeSQL" , 99 , -1 };

/* Reset class/struct taginfo */
extern "C" void G__cpp_reset_tagtableG__Tree() {
  G__G__TreeLN_TClass.tagnum = -1 ;
  G__G__TreeLN_TBuffer.tagnum = -1 ;
  G__G__TreeLN_TDirectory.tagnum = -1 ;
  G__G__TreeLN_TMemberInspector.tagnum = -1 ;
  G__G__TreeLN_TObject.tagnum = -1 ;
  G__G__TreeLN_TNamed.tagnum = -1 ;
  G__G__TreeLN_TString.tagnum = -1 ;
  G__G__TreeLN_TMemberStreamer.tagnum = -1 ;
  G__G__TreeLN_TVirtualCollectionProxy.tagnum = -1 ;
  G__G__TreeLN_basic_istreamlEcharcOchar_traitslEchargRsPgR.tagnum = -1 ;
  G__G__TreeLN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR.tagnum = -1 ;
  G__G__TreeLN_reverse_iteratorlEvectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__G__TreeLN_TList.tagnum = -1 ;
  G__G__TreeLN_TBrowser.tagnum = -1 ;
  G__G__TreeLN_TObjArray.tagnum = -1 ;
  G__G__TreeLN_TMethod.tagnum = -1 ;
  G__G__TreeLN_TStreamerElement.tagnum = -1 ;
  G__G__TreeLN_TClonesArray.tagnum = -1 ;
  G__G__TreeLN_TRefTable.tagnum = -1 ;
  G__G__TreeLN_TVirtualArray.tagnum = -1 ;
  G__G__TreeLN_TStreamerInfoActions.tagnum = -1 ;
  G__G__TreeLN_TStreamerInfoActionscLcLTActionSequence.tagnum = -1 ;
  G__G__TreeLN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR.tagnum = -1 ;
  G__G__TreeLN_reverse_iteratorlEvectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__G__TreeLN_TBuffercLcLEMode.tagnum = -1 ;
  G__G__TreeLN_TDatime.tagnum = -1 ;
  G__G__TreeLN_TFile.tagnum = -1 ;
  G__G__TreeLN_TKey.tagnum = -1 ;
  G__G__TreeLN_TTree.tagnum = -1 ;
  G__G__TreeLN_TBranch.tagnum = -1 ;
  G__G__TreeLN_TBasket.tagnum = -1 ;
  G__G__TreeLN_TSQLResult.tagnum = -1 ;
  G__G__TreeLN_TSQLRow.tagnum = -1 ;
  G__G__TreeLN_TBufferSQL.tagnum = -1 ;
  G__G__TreeLN_TBasketSQL.tagnum = -1 ;
  G__G__TreeLN_vectorlEintcOallocatorlEintgRsPgR.tagnum = -1 ;
  G__G__TreeLN_vectorlEintcOallocatorlEintgRsPgRcLcLiterator.tagnum = -1 ;
  G__G__TreeLN_reverse_iteratorlEvectorlEintcOallocatorlEintgRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__G__TreeLN_TCollection.tagnum = -1 ;
  G__G__TreeLN_TIterator.tagnum = -1 ;
  G__G__TreeLN_TSeqCollection.tagnum = -1 ;
  G__G__TreeLN_TObjLink.tagnum = -1 ;
  G__G__TreeLN_iteratorlEbidirectional_iterator_tagcOTObjectmUcOlongcOconstsPTObjectmUmUcOconstsPTObjectmUaNgR.tagnum = -1 ;
  G__G__TreeLN_TBranchElement.tagnum = -1 ;
  G__G__TreeLN_TVirtualBranchBrowsable.tagnum = -1 ;
  G__G__TreeLN_listlEvoidmUcOallocatorlEvoidmUgRsPgR.tagnum = -1 ;
  G__G__TreeLN_TMethodBrowsable.tagnum = -1 ;
  G__G__TreeLN_TNonSplitBrowsable.tagnum = -1 ;
  G__G__TreeLN_TCollectionPropertyBrowsable.tagnum = -1 ;
  G__G__TreeLN_TCollectionMethodBrowsable.tagnum = -1 ;
  G__G__TreeLN_TAttFill.tagnum = -1 ;
  G__G__TreeLN_EDataType.tagnum = -1 ;
  G__G__TreeLN_TLeaf.tagnum = -1 ;
  G__G__TreeLN_TBranchcLcLdA.tagnum = -1 ;
  G__G__TreeLN_TTreeCloner.tagnum = -1 ;
  G__G__TreeLN_TBranchClones.tagnum = -1 ;
  G__G__TreeLN_TClassRef.tagnum = -1 ;
  G__G__TreeLN_TMethodCall.tagnum = -1 ;
  G__G__TreeLN_maplEstringcOTObjArraymUcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOTObjArraymUgRsPgRsPgR.tagnum = -1 ;
  G__G__TreeLN_TAttLine.tagnum = -1 ;
  G__G__TreeLN_TAttMarker.tagnum = -1 ;
  G__G__TreeLN_TArrayD.tagnum = -1 ;
  G__G__TreeLN_TArrayI.tagnum = -1 ;
  G__G__TreeLN_TH1.tagnum = -1 ;
  G__G__TreeLN_TTreeFormula.tagnum = -1 ;
  G__G__TreeLN_TSelector.tagnum = -1 ;
  G__G__TreeLN_TPrincipal.tagnum = -1 ;
  G__G__TreeLN_TVirtualIndex.tagnum = -1 ;
  G__G__TreeLN_TVirtualTreePlayer.tagnum = -1 ;
  G__G__TreeLN_TEventList.tagnum = -1 ;
  G__G__TreeLN_TEntryList.tagnum = -1 ;
  G__G__TreeLN_TFriendElement.tagnum = -1 ;
  G__G__TreeLN_TCut.tagnum = -1 ;
  G__G__TreeLN_TBranchRef.tagnum = -1 ;
  G__G__TreeLN_TStreamerInfo.tagnum = -1 ;
  G__G__TreeLN_TTreecLcLELockStatusBits.tagnum = -1 ;
  G__G__TreeLN_TTreecLcLSetBranchAddressStatus.tagnum = -1 ;
  G__G__TreeLN_TTreecLcLdA.tagnum = -1 ;
  G__G__TreeLN_TTreeFriendLeafIter.tagnum = -1 ;
  G__G__TreeLN_TVirtualCollectionIterators.tagnum = -1 ;
  G__G__TreeLN_TVirtualCollectionPtrIterators.tagnum = -1 ;
  G__G__TreeLN_TBranchElementcLcLdA.tagnum = -1 ;
  G__G__TreeLN_TBranchObject.tagnum = -1 ;
  G__G__TreeLN_TBranchObjectcLcLdA.tagnum = -1 ;
  G__G__TreeLN_vectorlEstringcOallocatorlEstringgRsPgR.tagnum = -1 ;
  G__G__TreeLN_reverse_iteratorlEvectorlEstringcOallocatorlEstringgRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__G__TreeLN_TIndArray.tagnum = -1 ;
  G__G__TreeLN_TBranchSTL.tagnum = -1 ;
  G__G__TreeLN_TBufferFile.tagnum = -1 ;
  G__G__TreeLN_vectorlETStreamerInfomUcOallocatorlETStreamerInfomUgRsPgR.tagnum = -1 ;
  G__G__TreeLN_reverse_iteratorlEvectorlETStreamerInfomUcOallocatorlETStreamerInfomUgRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__G__TreeLN_TChainElement.tagnum = -1 ;
  G__G__TreeLN_TChainElementcLcLEStatusBits.tagnum = -1 ;
  G__G__TreeLN_TChain.tagnum = -1 ;
  G__G__TreeLN_TChaincLcLdA.tagnum = -1 ;
  G__G__TreeLN_TEntryListBlock.tagnum = -1 ;
  G__G__TreeLN_TEntryListBlockcLcLdA.tagnum = -1 ;
  G__G__TreeLN_TEntryListcLcLdA.tagnum = -1 ;
  G__G__TreeLN_TEntryListFromFile.tagnum = -1 ;
  G__G__TreeLN_TEntryListFromFilecLcLdA.tagnum = -1 ;
  G__G__TreeLN_TFriendElementcLcLdA.tagnum = -1 ;
  G__G__TreeLN_TLeafcLcLdA.tagnum = -1 ;
  G__G__TreeLN_TLeafB.tagnum = -1 ;
  G__G__TreeLN_TLeafC.tagnum = -1 ;
  G__G__TreeLN_TLeafD.tagnum = -1 ;
  G__G__TreeLN_TLeafElement.tagnum = -1 ;
  G__G__TreeLN_TLeafF.tagnum = -1 ;
  G__G__TreeLN_TLeafI.tagnum = -1 ;
  G__G__TreeLN_TLeafL.tagnum = -1 ;
  G__G__TreeLN_TLeafObject.tagnum = -1 ;
  G__G__TreeLN_TLeafObjectcLcLdA.tagnum = -1 ;
  G__G__TreeLN_TLeafO.tagnum = -1 ;
  G__G__TreeLN_TLeafS.tagnum = -1 ;
  G__G__TreeLN_TNtupleD.tagnum = -1 ;
  G__G__TreeLN_TNtuple.tagnum = -1 ;
  G__G__TreeLN_TMacro.tagnum = -1 ;
  G__G__TreeLN_TQueryResult.tagnum = -1 ;
  G__G__TreeLN_TQueryResultcLcLEQueryStatus.tagnum = -1 ;
  G__G__TreeLN_TSelectorList.tagnum = -1 ;
  G__G__TreeLN_TSelectorcLcLEAbort.tagnum = -1 ;
  G__G__TreeLN_TSelectorCint.tagnum = -1 ;
  G__G__TreeLN_TSelectorScalar.tagnum = -1 ;
  G__G__TreeLN_TParameterlElongsPlonggR.tagnum = -1 ;
  G__G__TreeLN_TFileCacheRead.tagnum = -1 ;
  G__G__TreeLN_TTreeCache.tagnum = -1 ;
  G__G__TreeLN_TThread.tagnum = -1 ;
  G__G__TreeLN_TCondition.tagnum = -1 ;
  G__G__TreeLN_TMutex.tagnum = -1 ;
  G__G__TreeLN_TTreeCacheUnzip.tagnum = -1 ;
  G__G__TreeLN_TTreeCacheUnzipcLcLEParUnzipMode.tagnum = -1 ;
  G__G__TreeLN_dequelEintcOallocatorlEintgRsPgR.tagnum = -1 ;
  G__G__TreeLN_queuelEintcOdequelEintcOallocatorlEintgRsPgRsPgR.tagnum = -1 ;
  G__G__TreeLN_TTreeClonercLcLECloneMethod.tagnum = -1 ;
  G__G__TreeLN_TTreeClonercLcLEClonerOptions.tagnum = -1 ;
  G__G__TreeLN_TTreeResult.tagnum = -1 ;
  G__G__TreeLN_TTreeRow.tagnum = -1 ;
  G__G__TreeLN_TSQLServer.tagnum = -1 ;
  G__G__TreeLN_TTreeSQL.tagnum = -1 ;
}


extern "C" void G__cpp_setup_tagtableG__Tree() {

   /* Setting up class,struct,union tag entry */
   G__get_linked_tagnum_fwd(&G__G__TreeLN_TClass);
   G__get_linked_tagnum_fwd(&G__G__TreeLN_TBuffer);
   G__get_linked_tagnum_fwd(&G__G__TreeLN_TDirectory);
   G__get_linked_tagnum_fwd(&G__G__TreeLN_TMemberInspector);
   G__get_linked_tagnum_fwd(&G__G__TreeLN_TObject);
   G__get_linked_tagnum_fwd(&G__G__TreeLN_TNamed);
   G__get_linked_tagnum_fwd(&G__G__TreeLN_TString);
   G__get_linked_tagnum_fwd(&G__G__TreeLN_TMemberStreamer);
   G__get_linked_tagnum_fwd(&G__G__TreeLN_TVirtualCollectionProxy);
   G__get_linked_tagnum_fwd(&G__G__TreeLN_basic_istreamlEcharcOchar_traitslEchargRsPgR);
   G__get_linked_tagnum_fwd(&G__G__TreeLN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR);
   G__get_linked_tagnum_fwd(&G__G__TreeLN_reverse_iteratorlEvectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgRcLcLiteratorgR);
   G__get_linked_tagnum_fwd(&G__G__TreeLN_TList);
   G__get_linked_tagnum_fwd(&G__G__TreeLN_TBrowser);
   G__get_linked_tagnum_fwd(&G__G__TreeLN_TObjArray);
   G__get_linked_tagnum_fwd(&G__G__TreeLN_TMethod);
   G__get_linked_tagnum_fwd(&G__G__TreeLN_TStreamerElement);
   G__get_linked_tagnum_fwd(&G__G__TreeLN_TClonesArray);
   G__get_linked_tagnum_fwd(&G__G__TreeLN_TRefTable);
   G__get_linked_tagnum_fwd(&G__G__TreeLN_TVirtualArray);
   G__get_linked_tagnum_fwd(&G__G__TreeLN_TStreamerInfoActions);
   G__get_linked_tagnum_fwd(&G__G__TreeLN_TStreamerInfoActionscLcLTActionSequence);
   G__get_linked_tagnum_fwd(&G__G__TreeLN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__TreeLN_reverse_iteratorlEvectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgRcLcLiteratorgR);
   G__get_linked_tagnum_fwd(&G__G__TreeLN_TBuffercLcLEMode);
   G__get_linked_tagnum_fwd(&G__G__TreeLN_TDatime);
   G__get_linked_tagnum_fwd(&G__G__TreeLN_TFile);
   G__get_linked_tagnum_fwd(&G__G__TreeLN_TKey);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__TreeLN_TTree),sizeof(TTree),-1,130816,"Tree descriptor (the main ROOT I/O class)",G__setup_memvarTTree,G__setup_memfuncTTree);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__TreeLN_TBranch),sizeof(TBranch),-1,130816,"Branch descriptor",G__setup_memvarTBranch,G__setup_memfuncTBranch);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__TreeLN_TBasket),sizeof(TBasket),-1,130816,"the TBranch buffers",G__setup_memvarTBasket,G__setup_memfuncTBasket);
   G__get_linked_tagnum_fwd(&G__G__TreeLN_TSQLResult);
   G__get_linked_tagnum_fwd(&G__G__TreeLN_TSQLRow);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__TreeLN_TBufferSQL),sizeof(TBufferSQL),-1,327424,"Implementation of TBuffer to load and write to a SQL database",G__setup_memvarTBufferSQL,G__setup_memfuncTBufferSQL);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__TreeLN_TBasketSQL),sizeof(TBasketSQL),-1,327424,"the TBranch buffers",G__setup_memvarTBasketSQL,G__setup_memfuncTBasketSQL);
   G__get_linked_tagnum_fwd(&G__G__TreeLN_vectorlEintcOallocatorlEintgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__TreeLN_vectorlEintcOallocatorlEintgRsPgRcLcLiterator);
   G__get_linked_tagnum_fwd(&G__G__TreeLN_reverse_iteratorlEvectorlEintcOallocatorlEintgRsPgRcLcLiteratorgR);
   G__get_linked_tagnum_fwd(&G__G__TreeLN_TCollection);
   G__get_linked_tagnum_fwd(&G__G__TreeLN_TIterator);
   G__get_linked_tagnum_fwd(&G__G__TreeLN_TSeqCollection);
   G__get_linked_tagnum_fwd(&G__G__TreeLN_TObjLink);
   G__get_linked_tagnum_fwd(&G__G__TreeLN_iteratorlEbidirectional_iterator_tagcOTObjectmUcOlongcOconstsPTObjectmUmUcOconstsPTObjectmUaNgR);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__TreeLN_TBranchElement),sizeof(TBranchElement),-1,130816,"Branch in case of an object",G__setup_memvarTBranchElement,G__setup_memfuncTBranchElement);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__TreeLN_TVirtualBranchBrowsable),sizeof(TVirtualBranchBrowsable),-1,324608,"Base class for helper objects used for browsing",G__setup_memvarTVirtualBranchBrowsable,G__setup_memfuncTVirtualBranchBrowsable);
   G__get_linked_tagnum_fwd(&G__G__TreeLN_listlEvoidmUcOallocatorlEvoidmUgRsPgR);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__TreeLN_TMethodBrowsable),sizeof(TMethodBrowsable),-1,324608,"Helper object to browse methods",G__setup_memvarTMethodBrowsable,G__setup_memfuncTMethodBrowsable);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__TreeLN_TNonSplitBrowsable),sizeof(TNonSplitBrowsable),-1,324608,"Helper object to browse unsplit objects",G__setup_memvarTNonSplitBrowsable,G__setup_memfuncTNonSplitBrowsable);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__TreeLN_TCollectionPropertyBrowsable),sizeof(TCollectionPropertyBrowsable),-1,324608,"Helper object to add browsable collection properties",G__setup_memvarTCollectionPropertyBrowsable,G__setup_memfuncTCollectionPropertyBrowsable);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__TreeLN_TCollectionMethodBrowsable),sizeof(TCollectionMethodBrowsable),-1,324608,"Helper object to browse a collection's methods",G__setup_memvarTCollectionMethodBrowsable,G__setup_memfuncTCollectionMethodBrowsable);
   G__get_linked_tagnum_fwd(&G__G__TreeLN_TAttFill);
   G__get_linked_tagnum_fwd(&G__G__TreeLN_EDataType);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__TreeLN_TLeaf),sizeof(TLeaf),-1,130816,"Leaf: description of a Branch data type",G__setup_memvarTLeaf,G__setup_memfuncTLeaf);
   G__get_linked_tagnum_fwd(&G__G__TreeLN_TBranchcLcLdA);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__TreeLN_TTreeCloner),sizeof(TTreeCloner),-1,295936,"helper used for the fast cloning of TTrees.",G__setup_memvarTTreeCloner,G__setup_memfuncTTreeCloner);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__TreeLN_TBranchClones),sizeof(TBranchClones),-1,128256,"Branch in case of an array of clone objects",G__setup_memvarTBranchClones,G__setup_memfuncTBranchClones);
   G__get_linked_tagnum_fwd(&G__G__TreeLN_TClassRef);
   G__get_linked_tagnum_fwd(&G__G__TreeLN_TMethodCall);
   G__get_linked_tagnum_fwd(&G__G__TreeLN_maplEstringcOTObjArraymUcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOTObjArraymUgRsPgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__TreeLN_TAttLine);
   G__get_linked_tagnum_fwd(&G__G__TreeLN_TAttMarker);
   G__get_linked_tagnum_fwd(&G__G__TreeLN_TArrayD);
   G__get_linked_tagnum_fwd(&G__G__TreeLN_TArrayI);
   G__get_linked_tagnum_fwd(&G__G__TreeLN_TH1);
   G__get_linked_tagnum_fwd(&G__G__TreeLN_TTreeFormula);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__TreeLN_TSelector),sizeof(TSelector),-1,294656,"A utility class for tree and object processing",G__setup_memvarTSelector,G__setup_memfuncTSelector);
   G__get_linked_tagnum_fwd(&G__G__TreeLN_TPrincipal);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__TreeLN_TVirtualIndex),sizeof(TVirtualIndex),-1,324873,"Abstract interface for Tree Index",G__setup_memvarTVirtualIndex,G__setup_memfuncTVirtualIndex);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__TreeLN_TVirtualTreePlayer),sizeof(TVirtualTreePlayer),-1,29987,"Abstract interface for Tree players",G__setup_memvarTVirtualTreePlayer,G__setup_memfuncTVirtualTreePlayer);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__TreeLN_TEventList),sizeof(TEventList),-1,130816,"A list of selected entries in a TTree.",G__setup_memvarTEventList,G__setup_memfuncTEventList);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__TreeLN_TEntryList),sizeof(TEntryList),-1,327424,"A list of entries in a TTree",G__setup_memvarTEntryList,G__setup_memfuncTEntryList);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__TreeLN_TFriendElement),sizeof(TFriendElement),-1,327424,"A friend element of another TTree",G__setup_memvarTFriendElement,G__setup_memfuncTFriendElement);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__TreeLN_TCut),sizeof(TCut),-1,327424,"A specialized string object used for TTree selections",G__setup_memvarTCut,G__setup_memfuncTCut);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__TreeLN_TBranchRef),sizeof(TBranchRef),-1,324864,"to support referenced objects on other branches",G__setup_memvarTBranchRef,G__setup_memfuncTBranchRef);
   G__get_linked_tagnum_fwd(&G__G__TreeLN_TStreamerInfo);
   G__get_linked_tagnum_fwd(&G__G__TreeLN_TTreecLcLELockStatusBits);
   G__get_linked_tagnum_fwd(&G__G__TreeLN_TTreecLcLSetBranchAddressStatus);
   G__get_linked_tagnum_fwd(&G__G__TreeLN_TTreecLcLdA);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__TreeLN_TTreeFriendLeafIter),sizeof(TTreeFriendLeafIter),-1,36608,"Linked list iterator",G__setup_memvarTTreeFriendLeafIter,G__setup_memfuncTTreeFriendLeafIter);
   G__get_linked_tagnum_fwd(&G__G__TreeLN_TVirtualCollectionIterators);
   G__get_linked_tagnum_fwd(&G__G__TreeLN_TVirtualCollectionPtrIterators);
   G__get_linked_tagnum_fwd(&G__G__TreeLN_TBranchElementcLcLdA);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__TreeLN_TBranchObject),sizeof(TBranchObject),-1,128256,"Branch in case of an object",G__setup_memvarTBranchObject,G__setup_memfuncTBranchObject);
   G__get_linked_tagnum_fwd(&G__G__TreeLN_TBranchObjectcLcLdA);
   G__get_linked_tagnum_fwd(&G__G__TreeLN_vectorlEstringcOallocatorlEstringgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__TreeLN_reverse_iteratorlEvectorlEstringcOallocatorlEstringgRsPgRcLcLiteratorgR);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__TreeLN_TIndArray),sizeof(TIndArray),-1,263424,(char*)NULL,G__setup_memvarTIndArray,G__setup_memfuncTIndArray);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__TreeLN_TBranchSTL),sizeof(TBranchSTL),-1,324864,"Branch handling STL collection of pointers",G__setup_memvarTBranchSTL,G__setup_memfuncTBranchSTL);
   G__get_linked_tagnum_fwd(&G__G__TreeLN_TBufferFile);
   G__get_linked_tagnum_fwd(&G__G__TreeLN_vectorlETStreamerInfomUcOallocatorlETStreamerInfomUgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__TreeLN_reverse_iteratorlEvectorlETStreamerInfomUcOallocatorlETStreamerInfomUgRsPgRcLcLiteratorgR);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__TreeLN_TChainElement),sizeof(TChainElement),-1,62720,"A chain element",G__setup_memvarTChainElement,G__setup_memfuncTChainElement);
   G__get_linked_tagnum_fwd(&G__G__TreeLN_TChainElementcLcLEStatusBits);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__TreeLN_TChain),sizeof(TChain),-1,130816,"A chain of TTrees",G__setup_memvarTChain,G__setup_memfuncTChain);
   G__get_linked_tagnum_fwd(&G__G__TreeLN_TChaincLcLdA);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__TreeLN_TEntryListBlock),sizeof(TEntryListBlock),-1,292608,"Used internally in TEntryList to store the entry numbers",G__setup_memvarTEntryListBlock,G__setup_memfuncTEntryListBlock);
   G__get_linked_tagnum_fwd(&G__G__TreeLN_TEntryListBlockcLcLdA);
   G__get_linked_tagnum_fwd(&G__G__TreeLN_TEntryListcLcLdA);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__TreeLN_TEntryListFromFile),sizeof(TEntryListFromFile),-1,324864,"Manager for entry lists from different files",G__setup_memvarTEntryListFromFile,G__setup_memfuncTEntryListFromFile);
   G__get_linked_tagnum_fwd(&G__G__TreeLN_TEntryListFromFilecLcLdA);
   G__get_linked_tagnum_fwd(&G__G__TreeLN_TFriendElementcLcLdA);
   G__get_linked_tagnum_fwd(&G__G__TreeLN_TLeafcLcLdA);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__TreeLN_TLeafB),sizeof(TLeafB),-1,324864,"A TLeaf for an 8 bit Integer data type.",G__setup_memvarTLeafB,G__setup_memfuncTLeafB);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__TreeLN_TLeafC),sizeof(TLeafC),-1,324864,"A TLeaf for a variable length string.",G__setup_memvarTLeafC,G__setup_memfuncTLeafC);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__TreeLN_TLeafD),sizeof(TLeafD),-1,324864,"A TLeaf for a 64 bit floating point data type.",G__setup_memvarTLeafD,G__setup_memfuncTLeafD);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__TreeLN_TLeafElement),sizeof(TLeafElement),-1,324864,"A TLeaf for a general object derived from TObject.",G__setup_memvarTLeafElement,G__setup_memfuncTLeafElement);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__TreeLN_TLeafF),sizeof(TLeafF),-1,324864,"A TLeaf for a 32 bit floating point data type.",G__setup_memvarTLeafF,G__setup_memfuncTLeafF);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__TreeLN_TLeafI),sizeof(TLeafI),-1,324864,"A TLeaf for an Integer data type.",G__setup_memvarTLeafI,G__setup_memfuncTLeafI);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__TreeLN_TLeafL),sizeof(TLeafL),-1,324864,"A TLeaf for a 64 bit Integer data type.",G__setup_memvarTLeafL,G__setup_memfuncTLeafL);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__TreeLN_TLeafObject),sizeof(TLeafObject),-1,128256,"A TLeaf for a general object derived from TObject.",G__setup_memvarTLeafObject,G__setup_memfuncTLeafObject);
   G__get_linked_tagnum_fwd(&G__G__TreeLN_TLeafObjectcLcLdA);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__TreeLN_TLeafO),sizeof(TLeafO),-1,324864,"A TLeaf for an 8 bit Integer data type.",G__setup_memvarTLeafO,G__setup_memfuncTLeafO);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__TreeLN_TLeafS),sizeof(TLeafS),-1,324864,"A TLeaf for a 16 bit Integer data type.",G__setup_memvarTLeafS,G__setup_memfuncTLeafS);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__TreeLN_TNtupleD),sizeof(TNtupleD),-1,130816,"A simple tree with branches of floats.",G__setup_memvarTNtupleD,G__setup_memfuncTNtupleD);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__TreeLN_TNtuple),sizeof(TNtuple),-1,130816,"A simple tree with branches of floats.",G__setup_memvarTNtuple,G__setup_memfuncTNtuple);
   G__get_linked_tagnum_fwd(&G__G__TreeLN_TMacro);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__TreeLN_TQueryResult),sizeof(TQueryResult),-1,324864,"Class describing a query",G__setup_memvarTQueryResult,G__setup_memfuncTQueryResult);
   G__get_linked_tagnum_fwd(&G__G__TreeLN_TQueryResultcLcLEQueryStatus);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__TreeLN_TSelectorList),sizeof(TSelectorList),-1,323840,"Special TList used in the TSelector",G__setup_memvarTSelectorList,G__setup_memfuncTSelectorList);
   G__get_linked_tagnum_fwd(&G__G__TreeLN_TSelectorcLcLEAbort);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__TreeLN_TSelectorCint),sizeof(TSelectorCint),-1,292096,"A utility class for tree and object processing (interpreted version)",G__setup_memvarTSelectorCint,G__setup_memfuncTSelectorCint);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__TreeLN_TSelectorScalar),sizeof(TSelectorScalar),-1,324864,"Mergable scalar",G__setup_memvarTSelectorScalar,G__setup_memfuncTSelectorScalar);
   G__get_linked_tagnum_fwd(&G__G__TreeLN_TParameterlElongsPlonggR);
   G__get_linked_tagnum_fwd(&G__G__TreeLN_TFileCacheRead);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__TreeLN_TTreeCache),sizeof(TTreeCache),-1,327424,"Specialization of TFileCacheRead for a TTree",G__setup_memvarTTreeCache,G__setup_memfuncTTreeCache);
   G__get_linked_tagnum_fwd(&G__G__TreeLN_TThread);
   G__get_linked_tagnum_fwd(&G__G__TreeLN_TCondition);
   G__get_linked_tagnum_fwd(&G__G__TreeLN_TMutex);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__TreeLN_TTreeCacheUnzip),sizeof(TTreeCacheUnzip),-1,327424,"Specialization of TTreeCache for parallel unzipping",G__setup_memvarTTreeCacheUnzip,G__setup_memfuncTTreeCacheUnzip);
   G__get_linked_tagnum_fwd(&G__G__TreeLN_TTreeCacheUnzipcLcLEParUnzipMode);
   G__get_linked_tagnum_fwd(&G__G__TreeLN_dequelEintcOallocatorlEintgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__TreeLN_queuelEintcOdequelEintcOallocatorlEintgRsPgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__TreeLN_TTreeClonercLcLECloneMethod);
   G__get_linked_tagnum_fwd(&G__G__TreeLN_TTreeClonercLcLEClonerOptions);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__TreeLN_TTreeResult),sizeof(TTreeResult),-1,324864,"TTree query result",G__setup_memvarTTreeResult,G__setup_memfuncTTreeResult);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__TreeLN_TTreeRow),sizeof(TTreeRow),-1,128256,"One row of an TTree query result",G__setup_memvarTTreeRow,G__setup_memfuncTTreeRow);
   G__get_linked_tagnum_fwd(&G__G__TreeLN_TSQLServer);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__TreeLN_TTreeSQL),sizeof(TTreeSQL),-1,323584,"TTree Implementation read and write to a SQL database.",G__setup_memvarTTreeSQL,G__setup_memfuncTTreeSQL);
}
extern "C" void G__cpp_setupG__Tree(void) {
  G__check_setup_version(30051515,"G__cpp_setupG__Tree()");
  G__set_cpp_environmentG__Tree();
  G__cpp_setup_tagtableG__Tree();

  G__cpp_setup_inheritanceG__Tree();

  G__cpp_setup_typetableG__Tree();

  G__cpp_setup_memvarG__Tree();

  G__cpp_setup_memfuncG__Tree();
  G__cpp_setup_globalG__Tree();
  G__cpp_setup_funcG__Tree();

   if(0==G__getsizep2memfunc()) G__get_sizep2memfuncG__Tree();
  return;
}
class G__cpp_setup_initG__Tree {
  public:
    G__cpp_setup_initG__Tree() { G__add_setup_func("G__Tree",(G__incsetup)(&G__cpp_setupG__Tree)); G__call_setup_funcs(); }
   ~G__cpp_setup_initG__Tree() { G__remove_setup_func("G__Tree"); }
};
G__cpp_setup_initG__Tree G__cpp_setup_initializerG__Tree;

---