// @(#)root/tree:$Id$
// Authors Rene Brun , Philippe Canal, Markus Frank  14/01/2001

/*************************************************************************
 * Copyright (C) 1995-2004, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/

//////////////////////////////////////////////////////////////////////////
//                                                                      //
// TBranchElement                                                       //
//                                                                      //
// A Branch for the case of an object                                   //
//                                                                      //
//////////////////////////////////////////////////////////////////////////

#include "TBranchElement.h"

#include "TBasket.h"
#include "TBranchObject.h"
#include "TBranchRef.h"
#include "TBrowser.h"
#include "TClass.h"
#include "TClassEdit.h"
#include "TClonesArray.h"
#include "TDataMember.h"
#include "TDataType.h"
#include "TError.h"
#include "TMath.h"
#include "TFile.h"
#include "TFolder.h"
#include "TLeafElement.h"
#include "TRealData.h"
#include "TStreamerElement.h"
#include "TStreamerInfo.h"
#include "TTree.h"
#include "TVirtualCollectionProxy.h"
#include "TVirtualCollectionIterators.h"
#include "TVirtualMutex.h"
#include "TVirtualPad.h"
#include "TBranchSTL.h"
#include "TVirtualArray.h"
#include "TBufferFile.h"
#include "TInterpreter.h"
#include "TROOT.h"

#include "TStreamerInfoActions.h"
#include "TSchemaRuleSet.h"

ClassImp(TBranchElement)

#if (__GNUC__ >= 3) || defined(__INTEL_COMPILER)
#if !defined(R__unlikely)
#define R__unlikely(expr) __builtin_expect(!!(expr), 0)
#endif
#if !defined(R__likely)
#define R__likely(expr) __builtin_expect(!!(expr), 1)
#endif
#else
#define R__unlikely(expr) expr
#define R__likely(expr) expr
#endif

//______________________________________________________________________________
namespace {
   void RemovePrefix(TString& str, const char* prefix) {
      // -- Remove a prefix from a string.
      if (str.Length() && prefix && strlen(prefix)) {
         if (!str.Index(prefix)) {
            str.Remove(0, strlen(prefix));
         }
      }
   }
   struct R__PushCache {
      TBufferFile &fBuffer;
      TVirtualArray *fOnfileObject;

      R__PushCache(TBufferFile &b, TVirtualArray *in, UInt_t size) : fBuffer(b), fOnfileObject(in) {
         if (fOnfileObject) {
            fOnfileObject->SetSize(size);
            fBuffer.PushDataCache( fOnfileObject );
         }
      }
      ~R__PushCache() {
         if (fOnfileObject) fBuffer.PopDataCache();
      }
   };
}

//______________________________________________________________________________
void TBranchElement::SwitchContainer(TObjArray* branches) {
   // -- Modify the container type of the branches

   const Int_t nbranches = branches->GetEntriesFast();
   for (Int_t i = 0; i < nbranches; ++i) {
      TBranchElement* br = (TBranchElement*) branches->At(i);
      switch (br->GetType()) {
         case 31: br->SetType(41); break;
         case 41: {
            br->SetType(31);
            br->fCollProxy = 0;
            break;
         }
      }
      br->SetReadLeavesPtr();
      br->SetFillLeavesPtr();
      // Note: This is a tail recursion.
      SwitchContainer(br->GetListOfBranches());
   }
}

//______________________________________________________________________________
namespace {
   Bool_t CanSelfReference(TClass *cl) {
      if (cl) {
         if (cl->GetCollectionProxy()) {
            TClass *inside = cl->GetCollectionProxy()->GetValueClass();
            if (inside) {
               return CanSelfReference(inside);
            } else {
               return kFALSE;
            }
         }
         const static TClassRef stringClass("std::string");
         if (cl == stringClass || cl == TString::Class()) {
            return kFALSE;
         }
         // Here we could scan through the TStreamerInfo to see if there
         // is any pointer anywhere and know whether this is a possibility
         // of selfreference (but watch out for very indirect cases).
         return kTRUE;
      }
      return kFALSE;
   }
}

//______________________________________________________________________________
TBranchElement::TBranchElement()
: TBranch()
, fClassName()
, fParentName()
, fClonesName()
, fCollProxy(0)
, fCheckSum(0)
, fClassVersion(0)
, fID(0)
, fType(0)
, fStreamerType(-1)
, fMaximum(0)
, fSTLtype(ROOT::kNotSTL)
, fNdata(1)
, fBranchCount(0)
, fBranchCount2(0)
, fInfo(0)
, fObject(0)
, fOnfileObject(0)
, fInit(kFALSE)
, fInitOffsets(kFALSE)
, fTargetClass()
, fCurrentClass()
, fParentClass()
, fBranchClass()
, fClonesClass()
, fBranchOffset(0)
, fBranchID(-1)
, fReadActionSequence(0)
, fFillActionSequence(0)
, fIterators(0)
, fWriteIterators(0)
, fPtrIterators(0)
{
   // -- Default and I/O constructor.
   fNleaves = 0;
   fReadLeaves = (ReadLeaves_t)&TBranchElement::ReadLeavesImpl;
   fFillLeaves = (FillLeaves_t)&TBranchElement::FillLeavesImpl;
}

//______________________________________________________________________________
TBranchElement::TBranchElement(TTree *tree, const char* bname, TStreamerInfo* sinfo, Int_t id, char* pointer, Int_t basketsize, Int_t splitlevel, Int_t btype)
: TBranch()
, fClassName(sinfo->GetName())
, fParentName()
, fClonesName()
, fCollProxy(0)
, fCheckSum(sinfo->GetCheckSum())
, fClassVersion(sinfo->GetClass()->GetClassVersion())
, fID(id)
, fType(0)
, fStreamerType(-1)
, fMaximum(0)
, fSTLtype(ROOT::kNotSTL)
, fNdata(1)
, fBranchCount(0)
, fBranchCount2(0)
, fInfo(sinfo)
, fObject(0)
, fOnfileObject(0)
, fInit(kTRUE)
, fInitOffsets(kFALSE)
, fTargetClass(fClassName)
, fCurrentClass()
, fParentClass()
, fBranchClass(sinfo->GetClass())
, fClonesClass()
, fBranchOffset(0)
, fBranchID(-1)
, fReadActionSequence(0)
, fFillActionSequence(0)
, fIterators(0)
, fWriteIterators(0)
, fPtrIterators(0)
{
   // -- Constructor when the branch object is not a TClonesArray nor an STL container.
   //
   // If splitlevel > 0 this branch in turn is split into sub-branches.

   Init(tree, 0, bname,sinfo,id,pointer,basketsize,splitlevel,btype);
}

//______________________________________________________________________________
TBranchElement::TBranchElement(TBranch *parent, const char* bname, TStreamerInfo* sinfo, Int_t id, char* pointer, Int_t basketsize, Int_t splitlevel, Int_t btype)
: TBranch()
, fClassName(sinfo->GetName())
, fParentName()
, fClonesName()
, fCollProxy(0)
, fCheckSum(sinfo->GetCheckSum())
, fClassVersion(sinfo->GetClass()->GetClassVersion())
, fID(id)
, fType(0)
, fStreamerType(-1)
, fMaximum(0)
, fSTLtype(ROOT::kNotSTL)
, fNdata(1)
, fBranchCount(0)
, fBranchCount2(0)
, fInfo(sinfo)
, fObject(0)
, fOnfileObject(0)
, fInit(kTRUE)
, fInitOffsets(kFALSE)
, fTargetClass( fClassName )
, fCurrentClass()
, fParentClass()
, fBranchClass(sinfo->GetClass())
, fClonesClass()
, fBranchOffset(0)
, fBranchID(-1)
, fReadActionSequence(0)
, fFillActionSequence(0)
, fIterators(0)
, fWriteIterators(0)
, fPtrIterators(0)
{
   // -- Constructor when the branch object is not a TClonesArray nor an STL container.
   //
   // If splitlevel > 0 this branch in turn is split into sub-branches.

   Init(parent ? parent->GetTree() : 0, parent, bname,sinfo,id,pointer,basketsize,splitlevel,btype);
}

//______________________________________________________________________________
void TBranchElement::Init(TTree *tree, TBranch *parent,const char* bname, TStreamerInfo* sinfo, Int_t id, char* pointer, Int_t basketsize, Int_t splitlevel, Int_t btype)
{
   // -- Init when the branch object is not a TClonesArray nor an STL container.
   //
   // If splitlevel > 0 this branch in turn is split into sub-branches.

   TString name(bname);

   // Set our TNamed attributes.
   SetName(name);
   SetTitle(name);

   // Set our TBranch attributes.
   fSplitLevel = splitlevel;
   fTree   = tree;
   if (fTree == 0) return;
   fMother = parent ? parent->GetMother() : this;
   fParent = parent;
   fDirectory = fTree->GetDirectory();
   fFileName = "";

   // Clear the bit kAutoDelete to specify that when reading
   // the object should not be deleted before calling Streamer.

   SetAutoDelete(kFALSE);

   fReadLeaves = (ReadLeaves_t)&TBranchElement::ReadLeavesImpl;
   fFillLeaves = (FillLeaves_t)&TBranchElement::FillLeavesImpl;

   //---------------------------------------------------------------------------
   // Handling the splitting of the STL collections of pointers
   //---------------------------------------------------------------------------
   Int_t splitSTLP = splitlevel - (splitlevel%TTree::kSplitCollectionOfPointers);
   splitlevel %= TTree::kSplitCollectionOfPointers;

   fCompress = -1;
   if (fTree->GetDirectory()) {
      TFile* bfile = fTree->GetDirectory()->GetFile();
      if (bfile) {
         fCompress = bfile->GetCompressionSettings();
      }
   }

   //
   // Initialize streamer type and element.
   //

   if (id > -1) {
      // We are *not* a top-level branch.
      TStreamerElement* element = sinfo->GetElement(id);
      fStreamerType = element->GetType();
   }

   //
   // Handle varying-length datatypes by allocating an offsets array.
   //
   // The fBits part of a TObject is of varying length because the pidf
   // is streamed only when the TObject is referenced by a TRef.
   //

   fEntryOffsetLen = 0;
   if (btype || (fStreamerType <= TVirtualStreamerInfo::kBase) || (fStreamerType == TVirtualStreamerInfo::kCharStar) || (fStreamerType == TVirtualStreamerInfo::kBits) || (fStreamerType > TVirtualStreamerInfo::kFloat16)) {
      fEntryOffsetLen = fTree->GetDefaultEntryOffsetLen();
   }

   //
   // Make sure the basket is big enough to contain the
   // entry offset array plus 100 bytes of data.
   //

   if (basketsize < (100 + fEntryOffsetLen)) {
      basketsize = 100 + fEntryOffsetLen;
   }
   fBasketSize = basketsize;


   //
   // Allocate and initialize the basket control arrays.
   //

   fBasketBytes = new Int_t[fMaxBaskets];
   fBasketEntry = new Long64_t[fMaxBaskets];
   fBasketSeek = new Long64_t[fMaxBaskets];

   for (Int_t i = 0; i < fMaxBaskets; ++i) {
      fBasketBytes[i] = 0;
      fBasketEntry[i] = 0;
      fBasketSeek[i] = 0;
   }

   // We need to keep track of the counter branch if we have
   // one, since we cannot set it until we have created our
   // leaf, which we do last.
   TBranchElement* brOfCounter = 0;

   if (id < 0) {
      // -- We are a top-level branch.  Don't split a top-level branch, TTree::Bronch will do that work.
      if (fBranchClass.GetClass()) {
         Bool_t hasCustomStreamer = kFALSE;
         Bool_t canSelfReference = CanSelfReference(fBranchClass);
         if (fBranchClass.GetClass()->IsTObject()) {
            if (canSelfReference) SetBit(kBranchObject);
            hasCustomStreamer = (!fBranchClass.GetClass()->GetCollectionProxy() && fBranchClass.GetClass()->TestBit(TClass::kHasCustomStreamerMember));
         } else {
            if (canSelfReference) SetBit(kBranchAny);
            hasCustomStreamer = !fBranchClass.GetClass()->GetCollectionProxy() && (fBranchClass.GetClass()->GetStreamer() != 0 || fBranchClass.GetClass()->TestBit(TClass::kHasCustomStreamerMember));
         }
         if (hasCustomStreamer) {
            fType = -1;
         }
      }
   } else {
      // -- We are a sub-branch of a split object.
      TStreamerElement* element = sinfo->GetElement(id);
      if ((fStreamerType == TVirtualStreamerInfo::kObject) || (fStreamerType == TVirtualStreamerInfo::kBase) || (fStreamerType == TVirtualStreamerInfo::kTNamed) || (fStreamerType == TVirtualStreamerInfo::kTObject) || (fStreamerType == TVirtualStreamerInfo::kObjectp) || (fStreamerType == TVirtualStreamerInfo::kObjectP)) {
         // -- If we are an object data member which inherits from TObject,
         // flag it so that later during i/o we will register the object
         // with the buffer so that pointers are handled correctly.
         if (CanSelfReference(fBranchClass)) {
            if (fBranchClass.GetClass()->IsTObject()) {
               SetBit(kBranchObject);
            } else {
               SetBit(kBranchAny);
            }
         }
      }
      if (element->IsA() == TStreamerBasicPointer::Class()) {
         // -- Fixup title with counter if we are a varying length array data member.
         TStreamerBasicPointer *bp = (TStreamerBasicPointer *)element;
         TString countname;
         countname = bname;
         Ssiz_t dot = countname.Last('.');
         if (dot>=0) {
            countname.Remove(dot+1);
         } else {
            countname = "";
         }
         countname += bp->GetCountName();
         brOfCounter = (TBranchElement *)fTree->GetBranch(countname);
         countname.Form("%s[%s]",name.Data(),bp->GetCountName());
         SetTitle(countname);

      } else if (element->IsA() == TStreamerLoop::Class()) {
         // -- Fixup title with counter if we are a varying length array data member.
         TStreamerLoop *bp = (TStreamerLoop *)element;
         TString countname;
         countname = bname;
         Ssiz_t dot = countname.Last('.');
         if (dot>=0) {
            countname.Remove(dot+1);
         } else {
            countname = "";
         }
         countname += bp->GetCountName();
         brOfCounter = (TBranchElement *)fTree->GetBranch(countname);
         countname.Form("%s[%s]",name.Data(),bp->GetCountName());
         SetTitle(countname);

      }

      if (splitlevel > 0) {
         // -- Create sub branches if requested by splitlevel.
         const char* elem_type = element->GetTypeName();
         fSTLtype = TClassEdit::UnderlyingIsSTLCont(elem_type);
         if (element->CannotSplit()) {
            fSplitLevel = 0;
         } else if (element->IsA() == TStreamerBase::Class()) {
            // -- We are a base class element.
            // Note: This does not include an STL container class which is
            //        being used as a base class because the streamer element
            //        in that case is not the base streamer element it is the
            //        STL streamer element.
            fType = 1;
            TClass* clOfElement = TClass::GetClass(element->GetName());
            Int_t nbranches = fBranches.GetEntriesFast();
            // Note: The following code results in base class branches
            //       having two different cases for what their parent
            //       class will be, this is very annoying.  It is also
            //       very annoying that the naming conventions for the
            //       sub-branch names are different as well.
            if (!strcmp(name, clOfElement->GetName())) {
               // -- If the branch's name is the same as the base class name,
               // which happens when we are a child branch of a top-level
               // branch whose name does not end in a dot and also has no
               // internal dots, elide the branch name, and keep the branch
               // heirarchy rooted at the ultimate parent, this keeps the base
               // class part of the branch name from propagating downwards.
               // FIXME: We are eliding the base class here, creating a break in the branch hierarchy.
               // Note: We can use parent class (cltop) != branch class (elemClass) to detection elision.
               Unroll("", fBranchClass.GetClass(), clOfElement, pointer, basketsize, splitlevel+splitSTLP, 0);
               SetReadLeavesPtr();
               SetFillLeavesPtr();
               return;
            }
            // If the branch's name is not the same as the base class name,
            // keep the branch name as a prefix (i.e., continue the branch
            // heirarchy), but start a new class heirarchy at the base class.
            //
            // Note: If the parent branch was created by the branch constructor
            //       which takes a folder as a parameter, then this case will
            //       be used, because the branch name will be the same as the
            //       parent branch name.
            // Note: This means that the sub-branches of a base class branch
            //       created by TTree::Bronch() have the base class name as
            //       as part of the branch name, while those created by
            //       Unroll() do not, ouch!!!
            //
            Unroll(name, clOfElement, clOfElement, pointer, basketsize, splitlevel+splitSTLP, 0);
            if (strchr(bname, '.')) {
               // Note: How can this happen?
               // Answer: This is the case when using the new branch
               //        naming convention where the top-level branch ends in dot.
               // Note: Well actually not entirely, we could also be a sub-branch
               //        of a split class, even when the top-level branch does not
               //        end in a dot.
               // Note: Or the top-level branch could have been created by the
               //        branch constructor which takes a folder as input, in which
               //        case the top-level branch name will have internal dots
               //        representing the folder hierarchy.
               SetReadLeavesPtr();
               SetFillLeavesPtr();
               return;
            }
            if (nbranches == fBranches.GetEntriesFast()) {
               // -- We did not add any branches in the Unroll, finalize our name to be the base class name, because Unroll did not do it for us.
               if (strlen(bname)) {
                  name.Form("%s.%s", bname, clOfElement->GetName());
               } else {
                  name.Form("%s", clOfElement->GetName());
               }
               SetName(name);
               SetTitle(name);
            }
            SetReadLeavesPtr();
            SetFillLeavesPtr();
            return;
         } else if (element->GetClassPointer() == TClonesArray::Class()) {
            // -- We are a TClonesArray element.
            Bool_t ispointer = element->IsaPointer();
            TClonesArray *clones;
            if (ispointer) {
               char **ppointer = (char**)(pointer);
               clones = (TClonesArray*)(*ppointer);
            } else {
               clones = (TClonesArray*)pointer;
            }
            //             basket->DeleteEntryOffset(); //entryoffset not required for the clonesarray counter
            fEntryOffsetLen = 0;
            // ===> Create a leafcount
            TLeaf* leaf = new TLeafElement(this, name, fID, fStreamerType);
            fNleaves = 1;
            fLeaves.Add(leaf);
            fTree->GetListOfLeaves()->Add(leaf);
            if (!clones) {
               SetFillLeavesPtr();
               return;
            }
            TClass* clOfClones = clones->GetClass();
            if (!clOfClones) {
               SetReadLeavesPtr();
               SetFillLeavesPtr();
               return;
            }
            fType = 3;
            // ===> create sub branches for each data member of a TClonesArray
            //check that the contained objects class name is part of the element title
            //This name is mandatory when reading the Tree later on and
            //the parent class with the pointer to the TClonesArray is not available.
            fClonesName = clOfClones->GetName();
            fClonesClass = clOfClones;
            TString aname;
            aname.Form(" (%s)", clOfClones->GetName());
            TString atitle = element->GetTitle();
            if (!atitle.Contains(aname)) {
               atitle += aname;
               element->SetTitle(atitle.Data());
            }
            TString branchname( name );
            branchname += "_";
            SetTitle(branchname);
            leaf->SetName(branchname);
            leaf->SetTitle(branchname);
            Unroll(name, clOfClones, clOfClones, pointer, basketsize, splitlevel+splitSTLP, 31);
            BuildTitle(name);
            SetReadLeavesPtr();
            SetFillLeavesPtr();
            return;
         } else if (((fSTLtype >= ROOT::kSTLvector) && (fSTLtype < ROOT::kSTLend)) || ((fSTLtype > -ROOT::kSTLend) && (fSTLtype <= -ROOT::kSTLvector))) {
            // -- We are an STL container element.
            TClass* contCl = TClass::GetClass(elem_type);
            fCollProxy = contCl->GetCollectionProxy()->Generate();
            TClass* valueClass = GetCollectionProxy()->GetValueClass();
            // Check to see if we can split the container.
            Bool_t cansplit = kTRUE;
            if (!valueClass) {
               cansplit = kFALSE;
            } else if ((valueClass == TString::Class()) || (valueClass == TClass::GetClass("string"))) {
               cansplit = kFALSE;
            } else if (GetCollectionProxy()->HasPointers() && !splitSTLP ) {
               cansplit = kFALSE;
            } else if (!valueClass->CanSplit() && !(GetCollectionProxy()->HasPointers() && splitSTLP)) {
               cansplit = kFALSE;
            } else if (valueClass->GetCollectionProxy()) {
               // -- A collection was stored in a collection, we choose not to split it.
               // Note: Splitting it would require extending TTreeFormula
               //       to understand how to access it.
               cansplit = kFALSE;
            }
            if (cansplit) {
               // -- Do the splitting work if we are allowed to.
               fType = 4;
               // Create a leaf for the master branch (the counter).
               TLeaf *leaf = new TLeafElement(this, name, fID, fStreamerType);
               fNleaves = 1;
               fLeaves.Add(leaf);
               fTree->GetListOfLeaves()->Add(leaf);
               // Check that the contained objects class name is part of the element title.
               // This name is mandatory when reading the tree later on and
               // the parent class with the pointer to the STL container is not available.
               fClonesName = valueClass->GetName();
               fClonesClass = valueClass;
               TString aname;
               aname.Form(" (%s)", valueClass->GetName());
               TString atitle = element->GetTitle();
               if (!atitle.Contains(aname)) {
                  atitle += aname;
                  element->SetTitle(atitle.Data());
               }
               TString branchname (name);
               branchname += "_";
               SetTitle(branchname);
               leaf->SetName(branchname);
               leaf->SetTitle(branchname);
               // Create sub branches for each data member of an STL container.
               Unroll(name, valueClass, valueClass, pointer, basketsize, splitlevel+splitSTLP, 41);
               BuildTitle(name);
               SetReadLeavesPtr();
               SetFillLeavesPtr();
               return;
            }
         } else if (!strchr(elem_type, '*') && ((fStreamerType == TVirtualStreamerInfo::kObject) || (fStreamerType == TVirtualStreamerInfo::kAny))) {
            // -- Create sub-branches for members that are classes.
            //
            // Note: This can only happen if we were called directly
            //       (usually by TClass::Bronch) because Unroll never
            //       calls us for an element of this type.
            fType = 2;
            TClass* clm = TClass::GetClass(elem_type);
            Int_t err = Unroll(name, clm, clm, pointer, basketsize, splitlevel+splitSTLP, 0);
            if (err >= 0) {
               // Return on success.
               // FIXME: Why not on error too?
               SetReadLeavesPtr();
               SetFillLeavesPtr();
               return;
            }
         }
      }
   }

   //
   // Create a leaf to represent this branch.
   //

   TLeaf* leaf = new TLeafElement(this, GetTitle(), fID, fStreamerType);
   leaf->SetTitle(GetTitle());
   fNleaves = 1;
   fLeaves.Add(leaf);
   fTree->GetListOfLeaves()->Add(leaf);

   //
   // If we have a counter branch set it now that we have
   // created our leaf, we cannot do it before then.
   //

   if (brOfCounter) {
      SetBranchCount(brOfCounter);
   }

   SetReadLeavesPtr();
   SetFillLeavesPtr();
}

//______________________________________________________________________________
TBranchElement::TBranchElement(TTree *tree, const char* bname, TClonesArray* clones, Int_t basketsize, Int_t splitlevel, Int_t compress)
: TBranch()
, fClassName("TClonesArray")
, fParentName()
, fInfo((TStreamerInfo*)TClonesArray::Class()->GetStreamerInfo())
, fTargetClass( fClassName )
, fCurrentClass()
, fParentClass()
, fBranchClass(TClonesArray::Class())
, fBranchID(-1)
, fReadActionSequence(0)
, fFillActionSequence(0)
, fIterators(0)
, fWriteIterators(0)
, fPtrIterators(0)
{
   // -- Constructor when the branch object is a TClonesArray.
   //
   // If splitlevel > 0 this branch in turn is split into sub branches.

   Init(tree, 0, bname, clones, basketsize, splitlevel, compress);
}

//______________________________________________________________________________
TBranchElement::TBranchElement(TBranch *parent, const char* bname, TClonesArray* clones, Int_t basketsize, Int_t splitlevel, Int_t compress)
: TBranch()
, fClassName("TClonesArray")
, fParentName()
, fInfo((TStreamerInfo*)TClonesArray::Class()->GetStreamerInfo())
, fTargetClass( fClassName )
, fCurrentClass()
, fParentClass()
, fBranchClass(TClonesArray::Class())
, fBranchID(-1)
, fReadActionSequence(0)
, fFillActionSequence(0)
, fIterators(0)
, fWriteIterators(0)
, fPtrIterators(0)
{
   // -- Constructor when the branch object is a TClonesArray.
   //
   // If splitlevel > 0 this branch in turn is split into sub branches.

   Init(parent ? parent->GetTree() : 0, parent, bname, clones, basketsize, splitlevel, compress);
}

//______________________________________________________________________________
void TBranchElement::Init(TTree *tree, TBranch *parent, const char* bname, TClonesArray* clones, Int_t basketsize, Int_t splitlevel, Int_t compress)
{
   // -- Init when the branch object is a TClonesArray.
   //
   // If splitlevel > 0 this branch in turn is split into sub branches.

   fCollProxy = 0;
   fSplitLevel    = splitlevel;
   fID            = 0;
   fInit          = kTRUE;
   fStreamerType  = -1;
   fType          = 0;
   fClassVersion  = TClonesArray::Class()->GetClassVersion();
   fCheckSum      = fInfo->GetCheckSum();
   fBranchCount   = 0;
   fBranchCount2  = 0;
   fObject        = 0;
   fOnfileObject  = 0;
   fMaximum       = 0;
   fBranchOffset  = 0;
   fSTLtype       = ROOT::kNotSTL;
   fInitOffsets   = kFALSE;

   fTree          = tree;
   fMother        = parent ? parent->GetMother() : this;
   fParent        = parent;
   fDirectory     = fTree->GetDirectory();
   fFileName      = "";

   SetName(bname);
   const char* name = GetName();
   SetTitle(name);
   //fClassName = fInfo->GetName();
   fCompress = compress;
   if (compress == -1 && fTree->GetDirectory()) {
      TFile *bfile = fTree->GetDirectory()->GetFile();
      if (bfile) fCompress = bfile->GetCompressionSettings();
   }

   if (basketsize < 100) basketsize = 100;
   fBasketSize     = basketsize;
   fBasketBytes    = new Int_t[fMaxBaskets];
   fBasketEntry    = new Long64_t[fMaxBaskets];
   fBasketSeek     = new Long64_t[fMaxBaskets];

   for (Int_t i=0;i<fMaxBaskets;i++) {
      fBasketBytes[i] = 0;
      fBasketEntry[i] = 0;
      fBasketSeek[i]  = 0;
   }

   // Reset the bit kAutoDelete to specify that when reading
   // the object should not be deleted before calling the streamer.
   SetAutoDelete(kFALSE);

   // create sub branches if requested by splitlevel
   if (splitlevel%TTree::kSplitCollectionOfPointers > 0) {
      TClass* clonesClass = clones->GetClass();
      if (!clonesClass) {
         Error("Init","Missing class object of the TClonesArray %s\n",clones->GetName());
         return;
      }
      fType = 3;
      // ===> Create a leafcount
      TLeaf* leaf = new TLeafElement(this, name, fID, fStreamerType);
      fNleaves = 1;
      fLeaves.Add(leaf);
      fTree->GetListOfLeaves()->Add(leaf);
      // ===> create sub branches for each data member of a TClonesArray
      fClonesName = clonesClass->GetName();
      fClonesClass = clonesClass;
      std::string branchname = name + std::string("_");
      SetTitle(branchname.c_str());
      leaf->SetName(branchname.c_str());
      leaf->SetTitle(branchname.c_str());
      Unroll(name, clonesClass, clonesClass, 0, basketsize, splitlevel, 31);
      BuildTitle(name);
      SetReadLeavesPtr();
      SetFillLeavesPtr();
      return;
   }

   if (!clones->GetClass() || CanSelfReference(clones->GetClass())) {
      SetBit(kBranchObject);
   }
   TLeaf *leaf = new TLeafElement(this, GetTitle(), fID, fStreamerType);
   leaf->SetTitle(GetTitle());
   fNleaves = 1;
   fLeaves.Add(leaf);
   fTree->GetListOfLeaves()->Add(leaf);

   SetReadLeavesPtr();
   SetFillLeavesPtr();
}

//______________________________________________________________________________
TBranchElement::TBranchElement(TTree *tree, const char* bname, TVirtualCollectionProxy* cont, Int_t basketsize, Int_t splitlevel, Int_t compress)
: TBranch()
, fClassName(cont->GetCollectionClass()->GetName())
, fParentName()
, fTargetClass( fClassName )
, fCurrentClass()
, fParentClass()
, fBranchClass(cont->GetCollectionClass())
, fBranchID(-1)
, fReadActionSequence(0)
, fFillActionSequence(0)
, fIterators(0)
, fWriteIterators(0)
, fPtrIterators(0)
{
   // -- Constructor when the branch object is an STL collection.
   //
   // If splitlevel > 0 this branch in turn is split into sub branches.

   Init(tree, 0, bname, cont, basketsize, splitlevel, compress);
}

//______________________________________________________________________________
TBranchElement::TBranchElement(TBranch *parent, const char* bname, TVirtualCollectionProxy* cont, Int_t basketsize, Int_t splitlevel, Int_t compress)
: TBranch()
, fClassName(cont->GetCollectionClass()->GetName())
, fParentName()
, fTargetClass( fClassName )
, fCurrentClass()
, fParentClass()
, fBranchClass(cont->GetCollectionClass())
, fBranchID(-1)
, fReadActionSequence(0)
, fFillActionSequence(0)
, fIterators(0)
, fWriteIterators(0)
, fPtrIterators(0)
{
   // -- Constructor when the branch object is an STL collection.
   //
   // If splitlevel > 0 this branch in turn is split into sub branches.

   Init(parent ? parent->GetTree() : 0, parent, bname, cont, basketsize, splitlevel, compress);
}

//______________________________________________________________________________
void TBranchElement::Init(TTree *tree, TBranch *parent, const char* bname, TVirtualCollectionProxy* cont, Int_t basketsize, Int_t splitlevel, Int_t compress)
{
   // -- Init when the branch object is an STL collection.
   //
   // If splitlevel > 0 this branch in turn is split into sub branches.

   fCollProxy = cont->Generate();
   TString name( bname );
   if (name[name.Length()-1]=='.') {
      name.Remove(name.Length()-1);
   }
   fInitOffsets   = kFALSE;
   fSplitLevel    = splitlevel;
   fInfo          = 0;
   fID            = -1;
   fInit          = kTRUE;
   fStreamerType  = -1; // TVirtualStreamerInfo::kSTLp;
   fType          = 0;
   fClassVersion  = cont->GetCollectionClass()->GetClassVersion();
   fCheckSum      = cont->GetCollectionClass()->GetCheckSum();
   fBranchCount   = 0;
   fBranchCount2  = 0;
   fObject        = 0;
   fOnfileObject  = 0;
   fMaximum       = 0;
   fBranchOffset  = 0;

   //Must be set here so that write actions will be properly matched to the ReadLeavesPtr
   fSTLtype = cont->GetCollectionType();
   if (fSTLtype < 0) {
      fSTLtype = -fSTLtype;
   }

   fTree          = tree;
   fMother        = parent ? parent->GetMother() : this;
   fParent        = parent;
   fDirectory     = fTree->GetDirectory();
   fFileName      = "";

   SetName(name);
   SetTitle(name);
   //fClassName = fBranchClass.GetClass()->GetName();
   fCompress = compress;
   if ((compress == -1) && fTree->GetDirectory()) {
      TFile* bfile = fTree->GetDirectory()->GetFile();
      if (bfile) {
         fCompress = bfile->GetCompressionSettings();
      }
   }

   if (basketsize < 100) {
      basketsize = 100;
   }
   fBasketSize     = basketsize;

   fBasketBytes    = new Int_t[fMaxBaskets];
   fBasketEntry    = new Long64_t[fMaxBaskets];
   fBasketSeek     = new Long64_t[fMaxBaskets];

   for (Int_t i = 0; i < fMaxBaskets; ++i) {
      fBasketBytes[i] = 0;
      fBasketEntry[i] = 0;
      fBasketSeek[i] = 0;
   }

   // Reset the bit kAutoDelete to specify that, when reading,
   // the object should not be deleted before calling the streamer.
   SetAutoDelete(kFALSE);

   // create sub branches if requested by splitlevel
   if ( (splitlevel%TTree::kSplitCollectionOfPointers > 0 && fBranchClass.GetClass() && fBranchClass.GetClass()->CanSplit()) ||
       (cont->HasPointers() && splitlevel > TTree::kSplitCollectionOfPointers && cont->GetValueClass() && cont->GetValueClass()->CanSplit() ) )
   {
      fType = 4;
      // ===> Create a leafcount
      TLeaf* leaf = new TLeafElement(this, name, fID, fStreamerType);
      fNleaves = 1;
      fLeaves.Add(leaf);
      fTree->GetListOfLeaves()->Add(leaf);
      // ===> create sub branches for each data member of an STL container value class
      TClass* valueClass = cont->GetValueClass();
      if (!valueClass) {
         return;
      }
      fClonesName = valueClass->GetName();
      fClonesClass = valueClass;
      TString branchname( name );
      branchname += "_";
      SetTitle(branchname);
      leaf->SetName(branchname);
      leaf->SetTitle(branchname);
      Unroll(name, valueClass, valueClass, 0, basketsize, splitlevel, 41);
      BuildTitle(name);
      SetReadLeavesPtr();
      SetFillLeavesPtr();
      return;
   }

   TLeaf *leaf = new TLeafElement(this, GetTitle(), fID, fStreamerType);
   leaf->SetTitle(GetTitle());
   fNleaves = 1;
   fLeaves.Add(leaf);
   fTree->GetListOfLeaves()->Add(leaf);
   SetReadLeavesPtr();
   SetFillLeavesPtr();
}

//______________________________________________________________________________
TBranchElement::~TBranchElement()
{
   // -- Destructor.

   // Release any allocated I/O buffers.
   if (fOnfileObject && TestBit(kOwnOnfileObj)) {
      delete fOnfileObject;
      fOnfileObject = 0;
   }
   ResetAddress();

   delete[] fBranchOffset;
   fBranchOffset = 0;

   fInfo = 0;
   fBranchCount2 = 0;
   fBranchCount = 0;

   if (fType == 4 || fType == 0) {
      // Only the top level TBranchElement containing an STL container,
      // owns the collectionproxy.
      delete fCollProxy;
   }
   fCollProxy = 0;

   delete fReadActionSequence;
   delete fFillActionSequence;
   delete fIterators;
   delete fWriteIterators;
   delete fPtrIterators;
}

//
// This function is located here to allow inlining by the optimizer.
//
//______________________________________________________________________________
inline TStreamerInfo* TBranchElement::GetInfoImp() const
{
   // -- Get streamer info for the branch class.

   // Note: we need to find a way to reduce the complexity of
   // this often executed condition.
   if (!fInfo || (fInfo && (!fInit || !fInfo->IsCompiled()))) {
      const_cast<TBranchElement*>(this)->InitInfo();
   }
   return fInfo;
}

//______________________________________________________________________________
TStreamerInfo* TBranchElement::GetInfo() const
{
   // -- Get streamer info for the branch class.

   return GetInfoImp();
}

//______________________________________________________________________________
void TBranchElement::Browse(TBrowser* b)
{
   // -- Browse the branch content.

   Int_t nbranches = fBranches.GetEntriesFast();
   if (nbranches > 0) {
      TList persistentBranches;
      TBranch* branch=0;
      TIter iB(&fBranches);
      while((branch=(TBranch*)iB())) {
         if (branch->IsFolder()) persistentBranches.Add(branch);
         else {
            // only show branches corresponding to persistent members
            TClass* cl=0;
            if (strlen(GetClonesName()))
               // this works both for top level branches and for sub-branches,
               // as GetClonesName() is properly updated for sub-branches
               cl=fClonesClass;
            else {
               cl=TClass::GetClass(GetClassName());

               // check if we're in a sub-branch of this class
               // we can only find out asking the streamer given our ID
               TStreamerElement *element=0;
               TClass* clsub=0;
               if (fID>=0 && GetInfoImp()
                   && GetInfoImp()->IsCompiled()
                   && ((element=GetInfoImp()->GetElement(fID)))
                   && ((clsub=element->GetClassPointer())))
                  cl=clsub;
            }
            if (cl) {
               TString strMember=branch->GetName();
               Size_t mempos=strMember.Last('.');
               if (mempos!=kNPOS)
                  strMember.Remove(0, (Int_t)mempos+1);
               mempos=strMember.First('[');
               if (mempos!=kNPOS)
                  strMember.Remove((Int_t)mempos);
               TDataMember* m=cl->GetDataMember(strMember);
               if (!m || m->IsPersistent()) persistentBranches.Add(branch);
            } else persistentBranches.Add(branch);
         } // branch if not a folder
      }
      persistentBranches.Browse(b);
      // add all public const methods without params
      if (GetBrowsables() && GetBrowsables()->GetSize())
         GetBrowsables()->Browse(b);
   } else {
      if (GetBrowsables() && GetBrowsables()->GetSize()) {
         GetBrowsables()->Browse(b);
         return;
      }
      // Get the name and strip any extra brackets
      // in order to get the full arrays.
      TString slash("/");
      TString escapedSlash("\\/");
      TString name = GetName();
      Int_t pos = name.First('[');
      if (pos != kNPOS) {
         name.Remove(pos);
      }
      TString mothername;
      if (GetMother()) {
         mothername = GetMother()->GetName();
         pos = mothername.First('[');
         if (pos != kNPOS) {
            mothername.Remove(pos);
         }
         Int_t len = mothername.Length();
         if (len) {
            if (mothername(len-1) != '.') {
               // We do not know for sure whether the mother's name is
               // already preprended.  So we need to check:
               //    a) it is prepended
               //    b) it is NOT the name of a daugher (i.e. mothername.mothername exist)
               TString doublename = mothername;
               doublename.Append(".");
               Int_t isthere = (name.Index(doublename) == 0);
               if (!isthere) {
                  name.Prepend(doublename);
               } else {
                  if (GetMother()->FindBranch(mothername)) {
                     doublename.Append(mothername);
                     isthere = (name.Index(doublename) == 0);
                     if (!isthere) {
                        mothername.Append(".");
                        name.Prepend(mothername);
                     }
                  } else {
                     // Nothing to do because the mother's name is
                     // already in the name.
                  }
               }
            } else {
               // If the mother's name end with a dot then
               // the daughter probably already contains the mother's name
               if (name.Index(mothername) == kNPOS) {
                  name.Prepend(mothername);
               }
            }
         }
      }
      name.ReplaceAll(slash, escapedSlash);
      GetTree()->Draw(name, "", b ? b->GetDrawOption() : "");
      if (gPad) {
         gPad->Update();
      }
   }
}

//______________________________________________________________________________
void TBranchElement::BuildTitle(const char* name)
{
   // -- Set branch and leaf name and title in the case of a container sub-branch.

   TString branchname;

   Int_t nbranches = fBranches.GetEntries();

   for (Int_t i = 0; i < nbranches; ++i) {
      TBranchElement* bre = (TBranchElement*) fBranches.At(i);
      if (fType == 3) {
         bre->SetType(31);
      } else if (fType == 4) {
         bre->SetType(41);
      } else {
         Error("BuildTitle", "This cannot happen, fType of parent is not 3 or 4!");
      }
      bre->fCollProxy = GetCollectionProxy();
      bre->BuildTitle(name);
      const char* fin = strrchr(bre->GetTitle(), '.');
      if (fin == 0) {
         continue;
      }
      // The branch counter for a sub-branch of a container is the container master branch.
      bre->SetBranchCount(this);
      TLeafElement* lf = (TLeafElement*) bre->GetListOfLeaves()->At(0);
      // If branch name is of the form fTracks.fCovar[3][4], then
      // set the title to fCovar[fTracks_].
      branchname = fin+1;
      Ssiz_t dim = branchname.First('[');
      if (dim>=0) {
         branchname.Remove(dim);
      }
      branchname += TString::Format("[%s_]",name);
      bre->SetTitle(branchname);
      if (lf) {
         lf->SetTitle(branchname);
      }
      // Is there a secondary branchcount?
      //
      // fBranchCount2 points to the secondary branchcount
      // in case a TClonesArray element itself has a branchcount.
      //
      // Example: In Event class with TClonesArray fTracks of Track objects.
      // if the Track object has two members
      //  Int_t    fNpoint;
      //  Float_t *fPoints;  //[fNpoint]
      // In this case the TBranchElement fTracks.fPoints has
      //  -its primary branchcount pointing to the branch fTracks
      //  -its secondary branchcount pointing to fTracks.fNpoint
      Int_t stype = bre->GetStreamerType();
      // FIXME: Should 60 be included here?
      if ((stype > 40) && (stype < 61)) {
         TString name2 (bre->GetName());
         Ssiz_t bn = name2.Last('.');
         if (bn<0) {
            continue;
         }
         TStreamerBasicPointer *el = (TStreamerBasicPointer*)bre->GetInfoImp()->GetElements()->FindObject(name2.Data()+bn+1);
         name2.Remove(bn+1);
         if (el) name2 += el->GetCountName();
         TBranchElement *bc2 = (TBranchElement*)fBranches.FindObject(name2);
         bre->SetBranchCount2(bc2);
      }
      bre->SetReadLeavesPtr();
      bre->SetFillLeavesPtr();
   }
}

//______________________________________________________________________________
Int_t TBranchElement::Fill()
{
   // -- Loop on all leaves of this branch to fill the basket buffer.
   //
   // The function returns the number of bytes committed to the
   // individual branches.  If a write error occurs, the number of
   // bytes returned is -1.  If no data are written, because, e.g.,
   // the branch is disabled, the number of bytes returned is 0.
   //
   // Note: We not not use any member functions from TLeafElement!

   Int_t nbytes = 0;
   Int_t nwrite = 0;
   Int_t nerror = 0;
   Int_t nbranches = fBranches.GetEntriesFast();

   ValidateAddress();

   //
   // If we are a top-level branch, update addresses.
   //

   if (fID < 0) {
      if (!fObject) {
         Error("Fill", "attempt to fill branch %s while addresss is not set", GetName());
         return 0;
      }
   }

   //
   // If the tree has a TRefTable, set the current branch if
   // branch is not a basic type.
   //

   // FIXME: This test probably needs to be extended past 10.
   if ((fType >= -1) && (fType < 10)) {
      TBranchRef* bref = fTree->GetBranchRef();
      if (bref) {
         fBranchID = bref->SetParent(this, fBranchID);
      }
   }

   if (!nbranches) {
      // No sub-branches.
      if (!TestBit(kDoNotProcess)) {
         nwrite = TBranch::Fill();
         if (nwrite < 0) {
            Error("Fill", "Failed filling branch:%s, nbytes=%d", GetName(), nwrite);
            ++nerror;
         } else {
            nbytes += nwrite;
         }
      }
   } else {
      // We have sub-branches.
      if (fType == 3 || fType == 4) {
         // TClonesArray or STL container counter
         nwrite = TBranch::Fill();
         if (nwrite < 0) {
            Error("Fill", "Failed filling branch:%s, nbytes=%d", GetName(), nwrite);
            ++nerror;
         } else {
            nbytes += nwrite;
         }
      } else {
         ++fEntries;
      }
      for (Int_t i = 0; i < nbranches; ++i) {
         TBranchElement* branch = (TBranchElement*) fBranches[i];
         if (!branch->TestBit(kDoNotProcess)) {
            nwrite = branch->Fill();
            if (nwrite < 0) {
               Error("Fill", "Failed filling branch:%s.%s, nbytes=%d", GetName(), branch->GetName(), nwrite);
               nerror++;
            } else {
               nbytes += nwrite;
            }
         }
      }
   }

   if (fTree->Debug() > 0) {
      // Debugging.
      Long64_t entry = fEntries;
      if ((entry >= fTree->GetDebugMin()) && (entry <= fTree->GetDebugMax())) {
         printf("Fill: %lld, branch=%s, nbytes=%d\n", entry, GetName(), nbytes);
      }
   }

   if (nerror != 0) {
      return -1;
   }

   return nbytes;
}

//______________________________________________________________________________
void TBranchElement::FillLeavesMakeClass(TBuffer& b)
{
   // -- Write leaves into i/o buffers for this branch.
   // For the case where the branch is set in MakeClass mode (decomposed object).

   ValidateAddress();

   //
   // Silently do nothing if we have no user i/o buffer.
   //

   if (!fObject) {
      return;
   }

   // -- TClonesArray top-level branch.  Write out number of entries, sub-branch writes the entries themselves.
   if(fType ==3) {
      // fClonesClass can not be zero since we are of type 3, see TBranchElement::Init
      TVirtualStreamerInfo* si = fClonesClass->GetStreamerInfo();
      if (!si) {
         Error("FillLeaves", "Cannot get streamer info for branch '%s' class '%s'", GetName(), fClonesClass->GetName());
         return;
      }
      b.ForceWriteInfo(si,kFALSE);
      Int_t* nptr = (Int_t*) fAddress;
      b << *nptr;
   } else if (fType == 31) {
      // -- TClonesArray sub-branch.  Write out the entries in the TClonesArray.
      // -- A MakeClass() tree, we must use fAddress instead of fObject.
      if (!fAddress) {
         // FIXME: Enable this message.
         //Error("FillLeaves", "Branch address not set for branch '%s'!", GetName());
         return;
      }
      Int_t atype = fStreamerType;
      if (atype > 54) {
         // Note: We are not supporting kObjectp, kAny, kObjectp,
         //       kObjectP, kTString, kTObject, kTNamed, kAnyp,
         //       kAnyP, kSTLp, kSTL, kSTLstring, kStreamer,
         //       kStreamLoop here, nor pointers to varying length
         //       arrays of them either.
         //       Nor do we support pointers to varying length
         //       arrays of kBits, kLong64, kULong64, nor kBool.
         return;
      }
      Int_t* nn = (Int_t*) fBranchCount->GetAddress();
      if (!nn) {
         Error("FillLeaves", "The branch counter address was zero!");
         return;
      }
      Int_t n = *nn;
      if (atype > 40) {
         // Note: We are not supporting pointer to varying length array.
         Error("FillLeaves", "Clonesa: %s, n=%d, sorry not supported yet", GetName(), n);
         return;
      }
      if (atype > 20) {
         atype -= 20;
         TLeafElement* leaf = (TLeafElement*) fLeaves.UncheckedAt(0);
         n = n * leaf->GetLenStatic();
      }
      switch (atype) {
            // Note: Type 0 is a base class and cannot happen here, see Unroll().
         case TVirtualStreamerInfo::kChar     /*  1 */: { b.WriteFastArray((Char_t*)    fAddress, n); break; }
         case TVirtualStreamerInfo::kShort    /*  2 */: { b.WriteFastArray((Short_t*)   fAddress, n); break; }
         case TVirtualStreamerInfo::kInt      /*  3 */: { b.WriteFastArray((Int_t*)     fAddress, n); break; }
         case TVirtualStreamerInfo::kLong     /*  4 */: { b.WriteFastArray((Long_t*)    fAddress, n); break; }
         case TVirtualStreamerInfo::kFloat    /*  5 */: { b.WriteFastArray((Float_t*)   fAddress, n); break; }
         case TVirtualStreamerInfo::kCounter  /*  6 */: { b.WriteFastArray((Int_t*)     fAddress, n); break; }
            // FIXME: We do nothing with type 7 (TVirtualStreamerInfo::kCharStar, char*) here!
         case TVirtualStreamerInfo::kDouble   /*  8 */: { b.WriteFastArray((Double_t*)  fAddress, n); break; }
         case TVirtualStreamerInfo::kDouble32 /*  9 */: {
            TVirtualStreamerInfo* si = GetInfoImp();
            // coverity[returned_null] structurally si->fComp (used in GetElem) can not be null.
            TStreamerElement* se = si->GetElement(fID);
            Double_t* xx = (Double_t*) fAddress;
            for (Int_t ii = 0; ii < n; ++ii) {
               b.WriteDouble32(&(xx[ii]),se);
            }
            break;
         }
         case TVirtualStreamerInfo::kFloat16 /*  19 */: {
            TVirtualStreamerInfo* si = GetInfoImp();
            // coverity[dereference] structurally si can not be null.
            TStreamerElement* se = (TStreamerElement*) si->GetElement(fID);
            Float_t* xx = (Float_t*) fAddress;
            for (Int_t ii = 0; ii < n; ++ii) {
               b.WriteFloat16(&(xx[ii]),se);
            }
            break;
         }
            // Note: Type 10 is unused for now.
         case TVirtualStreamerInfo::kUChar    /* 11 */: { b.WriteFastArray((UChar_t*)   fAddress, n); break; }
         case TVirtualStreamerInfo::kUShort   /* 12 */: { b.WriteFastArray((UShort_t*)  fAddress, n); break; }
         case TVirtualStreamerInfo::kUInt     /* 13 */: { b.WriteFastArray((UInt_t*)    fAddress, n); break; }
         case TVirtualStreamerInfo::kULong    /* 14 */: { b.WriteFastArray((ULong_t*)   fAddress, n); break; }
            // FIXME: This is wrong!!! TVirtualStreamerInfo::kBits is a variable length type.
         case TVirtualStreamerInfo::kBits     /* 15 */: { b.WriteFastArray((UInt_t*)    fAddress, n); break; }
         case TVirtualStreamerInfo::kLong64   /* 16 */: { b.WriteFastArray((Long64_t*)  fAddress, n); break; }
         case TVirtualStreamerInfo::kULong64  /* 17 */: { b.WriteFastArray((ULong64_t*) fAddress, n); break; }
         case TVirtualStreamerInfo::kBool     /* 18 */: { b.WriteFastArray((Bool_t*)    fAddress, n); break; }
      }
   }
}

//______________________________________________________________________________
void TBranchElement::FillLeavesCollection(TBuffer& b)
{
   // -- Write leaves into i/o buffers for this branch.
   // Case of a collection (fType == 4).

   // -- STL container top-level branch.  Write out number of entries, sub-branch writes the entries themselves.
   ValidateAddress();

   //
   // Silently do nothing if we have no user i/o buffer.
   //

   if (!fObject) {
      return;
   }

   TVirtualCollectionProxy* proxy = GetCollectionProxy();
   Int_t n = 0;
   // We are in a block so the helper pops as soon as possible.
   TVirtualCollectionProxy::TPushPop helper(proxy, fObject);
   n = proxy->Size();

   if (n > fMaximum) {
      fMaximum = n;
   }
   b << n;

   if(fSTLtype != ROOT::kSTLvector && proxy->HasPointers() && fSplitLevel > TTree::kSplitCollectionOfPointers ) {
      fPtrIterators->CreateIterators(fObject, proxy);
   } else {
      //NOTE: this does not work for not vectors since the CreateIterators expects a TGenCollectionProxy::TStaging as its argument!
      //NOTE: and those not work in general yet, since the TStaging object is neither created nor passed.
      //  We need to review how to avoid the need for a TStaging during the writing.
      if (proxy->GetProperties() & TVirtualCollectionProxy::kIsAssociative) {
         fWriteIterators->CreateIterators(fObject, proxy);
      } else {
         fIterators->CreateIterators(fObject, proxy);
      }
   }

}

//______________________________________________________________________________
void TBranchElement::FillLeavesCollectionSplitVectorPtrMember(TBuffer& b)
{
   // -- Write leaves into i/o buffers for this branch.
   // Case of a data member within a collection (fType == 41).

   ValidateAddress();

   //
   // Silently do nothing if we have no user i/o buffer.
   //

   if (!fObject) {
      return;
   }

   // FIXME: This wont work if a pointer to vector is split!
   TVirtualCollectionProxy::TPushPop helper(GetCollectionProxy(), fObject);
   // Note: We cannot pop the proxy here because we need it for the i/o.
   TStreamerInfo* si = (TStreamerInfo*)GetInfoImp();
   if (!si) {
      Error("FillLeaves", "Cannot get streamer info for branch '%s'", GetName());
      return;
   }

   TVirtualCollectionIterators *iter = fBranchCount->fIterators;
   R__ASSERT(0!=iter);
   b.ApplySequenceVecPtr(*fFillActionSequence,iter->fBegin,iter->fEnd);
}

//______________________________________________________________________________
void TBranchElement::FillLeavesCollectionSplitPtrMember(TBuffer& b)
{
   // -- Write leaves into i/o buffers for this branch.
   // Case of a data member within a collection (fType == 41).

   ValidateAddress();

   //
   // Silently do nothing if we have no user i/o buffer.
   //

   if (!fObject) {
      return;
   }

   // FIXME: This wont work if a pointer to vector is split!
   TVirtualCollectionProxy::TPushPop helper(GetCollectionProxy(), fObject);

   // Note: We cannot pop the proxy here because we need it for the i/o.
   TStreamerInfo* si = (TStreamerInfo*)GetInfoImp();
   if (!si) {
      Error("FillLeaves", "Cannot get streamer info for branch '%s'", GetName());
      return;
   }

   TVirtualCollectionPtrIterators *iter = fBranchCount->fPtrIterators;
   b.ApplySequence(*fFillActionSequence,iter->fBegin,iter->fEnd);

}

//______________________________________________________________________________
void TBranchElement::FillLeavesCollectionMember(TBuffer& b)
{
   // -- Write leaves into i/o buffers for this branch.
   // Case of a data member within a collection (fType == 41).

   ValidateAddress();

   //
   // Silently do nothing if we have no user i/o buffer.
   //

   if (!fObject) {
      return;
   }

   // FIXME: This wont work if a pointer to vector is split!
   TVirtualCollectionProxy::TPushPop helper(GetCollectionProxy(), fObject);
   // Note: We cannot pop the proxy here because we need it for the i/o.
   TStreamerInfo* si = (TStreamerInfo*)GetInfoImp();
   if (!si) {
      Error("FillLeaves", "Cannot get streamer info for branch '%s'", GetName());
      return;
   }

   TVirtualCollectionIterators *iter = fBranchCount->fIterators;
   R__ASSERT(0!=iter);
   b.ApplySequence(*fFillActionSequence,iter->fBegin,iter->fEnd);

}

//______________________________________________________________________________
void TBranchElement::FillLeavesAssociativeCollectionMember(TBuffer& b)
{
   // -- Write leaves into i/o buffers for this branch.
   // Case of a data member within a collection (fType == 41).

   ValidateAddress();

   //
   // Silently do nothing if we have no user i/o buffer.
   //

   if (!fObject) {
      return;
   }

   // FIXME: This wont work if a pointer to vector is split!
   TVirtualCollectionProxy::TPushPop helper(GetCollectionProxy(), fObject);
   // Note: We cannot pop the proxy here because we need it for the i/o.
   TStreamerInfo* si = (TStreamerInfo*)GetInfoImp();
   if (!si) {
      Error("FillLeaves", "Cannot get streamer info for branch '%s'", GetName());
      return;
   }

   TVirtualCollectionIterators *iter = fBranchCount->fWriteIterators;
   R__ASSERT(0!=iter);
   b.ApplySequence(*fFillActionSequence,iter->fBegin,iter->fEnd);

}

//______________________________________________________________________________
void TBranchElement::FillLeavesClones(TBuffer& b)
{
   // -- Write leaves into i/o buffers for this branch.
   // Case of a TClonesArray (fType == 3).

   // -- TClonesArray top-level branch.  Write out number of entries, sub-branch writes the entries themselves.
   ValidateAddress();

   //
   // Silently do nothing if we have no user i/o buffer.
   //

   if (!fObject) {
      return;
   }

   TClonesArray* clones = (TClonesArray*) fObject;
   Int_t n = clones->GetEntriesFast();
   if (n > fMaximum) {
      fMaximum = n;
   }
   b << n;
}

//______________________________________________________________________________
void TBranchElement::FillLeavesClonesMember(TBuffer& b)
{
   // -- Write leaves into i/o buffers for this branch.
   // Case of a data member within a TClonesArray (fType == 31).

   ValidateAddress();

   //
   // Silently do nothing if we have no user i/o buffer.
   //

   if (!fObject) {
      return;
   }

   TClonesArray* clones = (TClonesArray*) fObject;
   Int_t n = clones->GetEntriesFast();
   TStreamerInfo* si = (TStreamerInfo*)GetInfoImp();
   if (!si) {
      Error("FillLeaves", "Cannot get streamer info for branch '%s'", GetName());
      return;
   }

   char **arr = (char **)clones->GetObjectRef(0);
   char **end = arr + n;
   b.ApplySequenceVecPtr(*fFillActionSequence,arr,end);
}

//______________________________________________________________________________
void TBranchElement::FillLeavesCustomStreamer(TBuffer& b)
{
   // -- Write leaves into i/o buffers for this branch.
   // Case of a non  TObject, non collection class with a custom streamer

   ValidateAddress();

   //
   // Silently do nothing if we have no user i/o buffer.
   //

   if (!fObject) {
      return;
   }

   //
   // Remember tobjects written to the buffer so that
   // pointers are handled correctly later.

   if (TestBit(kBranchObject)) {
      b.MapObject((TObject*) fObject);
   } else if (TestBit(kBranchAny)) {
      b.MapObject(fObject, fBranchClass);
   }


   fBranchClass->Streamer(fObject,b);
}

//______________________________________________________________________________
void TBranchElement::FillLeavesMemberBranchCount(TBuffer& b)
{
   // -- Write leaves into i/o buffers for this branch.
   // For split-class branch, base class branch, data member branch, or top-level branch.
   // which do have a branch count and are not a counter.

   FillLeavesMember(b);
   /*
    ValidateAddress();

    //
    // Silently do nothing if we have no user i/o buffer.
    //

    if (!fObject) {
    return;
    }
    */
}

//______________________________________________________________________________
void TBranchElement::FillLeavesMemberCounter(TBuffer& b)
{
   // -- Write leaves into i/o buffers for this branch.
   // For split-class branch, base class branch, data member branch, or top-level branch.
   // which do not have a branch count and are a counter.

   ValidateAddress();

   //
   // Silently do nothing if we have no user i/o buffer.
   //

   if (!fObject) {
      return;
   }
   // -- Top-level, data member, base class, or split class branch.
   // A non-split top-level branch (0, and fID == -1)), a non-split object (0, and fID > -1), or a base class (1), or a split (non-TClonesArray, non-STL container) object (2).  Write out the object.
   // Note: A split top-level branch (0, and fID == -2) should not happen here, see Fill().
   // FIXME: What happens with a split base class branch,
   //        or a split class branch???
   TStreamerInfo* si = GetInfoImp();
   if (!si) {
      Error("FillLeaves", "Cannot get streamer info for branch '%s'", GetName());
      return;
   }
   // Since info is not null, fFillActionSequence is not null either.
   b.ApplySequence(*fFillActionSequence, fObject);
   // Int_t n = si->WriteBufferAux(b, &fObject, fID, 1, 0, 0);

   Int_t n = *(Int_t*)(fObject + si->TStreamerInfo::GetElementOffset(fID)); // or  GetInfoImp()->GetTypedValue<Int_t>(&fObject, fID, j, -1);
   if (n > fMaximum) {
      fMaximum = n;
   }

}

//______________________________________________________________________________
void TBranchElement::FillLeavesMember(TBuffer& b)
{
   // -- Write leaves into i/o buffers for this branch.
   // For split-class branch, base class branch, data member branch, or top-level branch.
   // which do not have a branch count and are not a counter.

   ValidateAddress();

   //
   // Silently do nothing if we have no user i/o buffer.
   //

   if (!fObject) {
      return;
   }

   if (TestBit(kBranchObject)) {
      b.MapObject((TObject*) fObject);
   } else if (TestBit(kBranchAny)) {
      b.MapObject(fObject, fBranchClass);
   }

   // -- Top-level, data member, base class, or split class branch.
   // A non-split top-level branch (0, and fID == -1)), a non-split object (0, and fID > -1), or a base class (1), or a split (non-TClonesArray, non-STL container) object (2).  Write out the object.
   // Note: A split top-level branch (0, and fID == -2) should not happen here, see Fill().
   // FIXME: What happens with a split base class branch,
   //        or a split class branch???
   TStreamerInfo* si = GetInfoImp();
   if (!si) {
      Error("FillLeaves", "Cannot get streamer info for branch '%s'", GetName());
      return;
   }
   // Since info is not null, fFillActionSequence is not null either.
   b.ApplySequence(*fFillActionSequence, fObject);

}


//______________________________________________________________________________
static void R__CleanName(std::string &name)
{
   // Remove trailing dimensions and make sure
   // there is a trailing dot.

   if (name[name.length()-1]==']') {
      std::size_t dim = name.find_first_of("[");
      if (dim != std::string::npos) {
         name.erase(dim);
      }
   }
   if (name[name.size()-1] != '.') {
      name += '.';
   }
}

//______________________________________________________________________________
TBranch* TBranchElement::FindBranch(const char *name)
{
   // Find the immediate sub-branch with passed name.

   // The default behavior of TBranch::FindBranch is sometimes
   // incorrect if this branch represent a base class, since
   // the base class name might or might not be in the name
   // of the sub-branches and might or might not be in the
   // name being passed.

   if (fID >= 0) {
      TVirtualStreamerInfo* si = GetInfoImp();
      TStreamerElement* se = si->GetElement(fID);
      if (se && se->IsBase()) {
         // We allow the user to pass only the last dotted component of the name.
         UInt_t len = strlen(name);
         std::string longnm;
         longnm.reserve(fName.Length()+len+3); // Enough space of fName + name + dots
         longnm = fName.Data();
         R__CleanName(longnm);
         longnm += name;
         std::string longnm_parent;
         longnm_parent.reserve(fName.Length()+len+3);
         longnm_parent = (GetMother()->GetSubBranch(this)->GetName());
         R__CleanName(longnm_parent);
         longnm_parent += name;  // Name without the base class name

         UInt_t namelen = strlen(name);

         TBranch* branch = 0;
         Int_t nbranches = fBranches.GetEntries();
         for(Int_t i = 0; i < nbranches; ++i) {
            branch = (TBranch*) fBranches.UncheckedAt(i);

            const char *brname = branch->GetName();
            UInt_t brlen = strlen(brname);
            if (brname[brlen-1]==']') {
               const char *dim = strchr(brname,'[');
               if (dim) {
                  brlen = dim - brname;
               }
            }
            if (namelen == brlen /* same effective size */
                && strncmp(name,brname,brlen) == 0) {
               return branch;
            }
            if (brlen == longnm.length()
                && strncmp(longnm.c_str(),brname,brlen) == 0) {
               return branch;
            }
            // This check is specific to base class
            if (brlen == longnm_parent.length()
                && strncmp(longnm_parent.c_str(),brname,brlen) == 0) {
               return branch;
            }

            if (namelen>brlen && name[brlen]=='.' && strncmp(name,brname,brlen)==0) {
               // The prefix subbranch name match the branch name.
               return branch->FindBranch(name+brlen+1);
            }
         }
      }
   }
   TBranch *result = TBranch::FindBranch(name);
   if (!result) {
      // Look in base classes if any
      Int_t nbranches = fBranches.GetEntries();
      for(Int_t i = 0; i < nbranches; ++i) {
         TObject *obj = fBranches.UncheckedAt(i);
         if(obj->IsA() != TBranchElement :: Class() )
            continue;
         TBranchElement *br = (TBranchElement*)obj;
         TVirtualStreamerInfo* si = br->GetInfoImp();
         if (si && br->GetID() >= 0) {
            TStreamerElement* se = si->GetElement(br->GetID());
            if (se && se->IsBase()) {
               result = br->FindBranch(name);
            }
         }
      }
   }
   return result;
}

//______________________________________________________________________________
TLeaf* TBranchElement::FindLeaf(const char *name)
{
   // -- Find the leaf corresponding to the name 'searchname'.

   TLeaf *leaf = TBranch::FindLeaf(name);

   if (leaf==0 && GetListOfLeaves()->GetEntries()==1) {
      TBranch *br = GetMother()->GetSubBranch( this );
      if( br->IsA() != TBranchElement::Class() )
         return 0;

      TBranchElement *parent = (TBranchElement*)br;
      if (parent==this || parent->GetID()<0 ) return 0;

      TVirtualStreamerInfo* si = parent->GetInfoImp();
      TStreamerElement* se = si->GetElement(parent->GetID());

      if (! se->IsBase() ) return 0;

      br = GetMother()->GetSubBranch( parent );
      if( br->IsA() != TBranchElement::Class() )
         return 0;

      TBranchElement *grand_parent = (TBranchElement*)br;

      std::string longname( grand_parent->GetName() );
      R__CleanName(longname);
      longname += name;

      std::string leafname( GetListOfLeaves()->At(0)->GetName() );

      if ( longname == leafname ) {
         return (TLeaf*)GetListOfLeaves()->At(0);
      }
   }
   return leaf;
}

//______________________________________________________________________________
char* TBranchElement::GetAddress() const
{
   // -- Get the branch address.
   //
   // If we are *not* owned by a MakeClass() tree:
   //
   //      If we are a top-level branch, return a pointer
   //      to the pointer to our object.
   //
   //      If we are *not* a top-level branch, return a pointer
   //      to our object.
   //
   // If we are owned by a MakeClass() tree:
   //
   //      Return a pointer to our object.
   //

   ValidateAddress();
   return fAddress;
}

//______________________________________________________________________________
void TBranchElement::InitInfo()
{
   // -- Init the streamer info for the branch class, try to compensate for class code unload/reload and schema evolution.

   if (!fInfo) {
      // We did not already have streamer info, so now we must find it.
      TClass* cl = fBranchClass.GetClass();

      //------------------------------------------------------------------------
      // Check if we're dealing with the name change
      //------------------------------------------------------------------------
      TClass* targetClass = 0;
      if( fTargetClass.GetClassName()[0] ) {
         targetClass = fTargetClass;
         if (!targetClass && GetCollectionProxy()) {
            // We are in the case where the branch holds a custom collection
            // proxy but the dictionary is not loaded, calling
            // GetCollectionProxy had the side effect of creating the TClass
            // corresponding to this emulated collection.
            targetClass = fTargetClass;
         }
         if ( !targetClass ) {
            Error( "InitInfo", "The target class dictionary is not present!" );
            return;
         }
      } else {
         targetClass = cl;
      }
      if (cl) {
         //---------------------------------------------------------------------
         // Get the streamer info for given version
         //---------------------------------------------------------------------
         {
            if ( (cl->Property() & kIsAbstract) && cl == targetClass) {
               TBranchElement *parent = (TBranchElement*)GetMother()->GetSubBranch(this);
               if (parent && parent != this && !parent->GetClass()->IsLoaded() ) {
                  // Our parent's class is emulated and we represent an abstract class.
                  // and the target class has not been set explicilty.
                  TString target = cl->GetName();
                  target += "@@emulated";
                  fTargetClass.SetName(target);

                  if (!fTargetClass) {
                     cl->GetStreamerInfoAbstractEmulated(fClassVersion);
                  }
                  targetClass = fTargetClass;
               }
            }
            if( targetClass != cl ) {
               fInfo = (TStreamerInfo*)targetClass->GetConversionStreamerInfo( cl, fClassVersion );
            } else {
               fInfo = (TStreamerInfo*)cl->GetStreamerInfo(fClassVersion);
            }
         }

         // FIXME: Check that the found streamer info checksum matches our branch class checksum here.
         // Check to see if the class code was unloaded/reloaded
         // since we were created.
         R__LOCKGUARD(gInterpreterMutex);
         if (fCheckSum && (cl->IsForeign() || (!cl->IsLoaded() && (fClassVersion == 1) && cl->GetStreamerInfos()->At(1) && (fCheckSum != ((TVirtualStreamerInfo*) cl->GetStreamerInfos()->At(1))->GetCheckSum())))) {
            // Try to compensate for a class that got unloaded on us.
            // Search through the streamer infos by checksum
            // and take the first match.

            TStreamerInfo* info;
            if( targetClass != cl )
               info = (TStreamerInfo*)targetClass->GetConversionStreamerInfo( cl, fCheckSum );
            else {
               info = (TStreamerInfo*)cl->FindStreamerInfo( fCheckSum );
               if (info) {
                  // Now that we found it, we need to make sure it is initialize (Find does not initialize the StreamerInfo).
                  info = (TStreamerInfo*)cl->GetStreamerInfo(info->GetClassVersion());
               }
            }
            if( info ) {
               fInfo = info;
               // We no longer reset the class version so that in case the user is passing us later
               // the address of a class that require (another) Conversion we can find the proper
               // StreamerInfo.
               //    fClassVersion = fInfo->GetClassVersion();
            }
         }
      }
   }

   //
   //  Fixup cached streamer info if necessary.
   //
   // FIXME:  What if the class code was unloaded/reloaded since we were cached?

   if (fInfo) {

      if (!fInfo->IsCompiled()) {
         // Streamer info has not yet been compiled.

         Error("InitInfo","StreamerInfo is not compiled.");
      }
      if (!fInit) {
         // We were read in from a file, figure out what our fID should be,
         // schema evolution must be considered.
         //
         // Force our fID to be the id of the first streamer element that matches our name.
         //
         if (GetID() > -1) {
            // We are *not* a top-level branch.
            std::string s(GetName());
            size_t pos = s.rfind('.');
            if (pos != std::string::npos) {
               s = s.substr(pos+1);
            }
            while ((pos = s.rfind('[')) != std::string::npos) {
               s = s.substr(0, pos);
            }
            int offset = 0;
            TStreamerElement* elt = fInfo->GetStreamerElement(s.c_str(), offset);
            if (elt && offset!=TStreamerInfo::kMissing) {
               size_t ndata = fInfo->GetNelement();
               fIDs.clear();
               for (size_t i = 0; i < ndata; ++i) {
                  if (fInfo->GetElement(i) == elt) {
                     if (elt->TestBit (TStreamerElement::kCache)
                         && (i+1) < ndata
                         && s == fInfo->GetElement(i)->GetName())
                     {
                        // If the TStreamerElement we found is storing the information in the
                        // cache and is a repeater, we need to use the real one (the next one).
                        // (At least until the cache/repeat mechanism is properly handle by
                        // ReadLeaves).
                        // fID = i+1;
                        fID = i;
                        if (elt->TestBit(TStreamerElement::kRepeat)) {
                           fIDs.push_back(fID+1);
                        } else if (fInfo->GetElement(i+1)->TestBit(TStreamerElement::kWrite)) {
                           fIDs.push_back(fID+1);
                        }
                     } else {
                        fID = i;
                     }
                     if (elt->TestBit (TStreamerElement::kCache)) {
                        SetBit(TBranchElement::kCache);
                     }
                     break;
                  }
               }
               for (size_t i = fID+1+(fIDs.size()); i < ndata; ++i) {
                  TStreamerElement *nextel = fInfo->GetElement(i);
                  // Add all (and only) the Artificial Elements that follows this StreamerInfo.
                  if (fType==31||fType==41) {
                     // The nested objects are unfolded and their branch can not be used to
                     // execute StreamerElements of this StreamerInfo.
                     if (nextel->GetType() == TStreamerInfo::kObject
                         || nextel->GetType() == TStreamerInfo::kAny) {
                        continue;
                     }
                  }
                  if (nextel->GetOffset() ==  TStreamerInfo::kMissing) {
                     // This element will be 'skipped', it's TBranchElement's fObject will null
                     // and thus can not be used to execute the artifical StreamerElements
                     continue;
                  }
                  if (nextel->IsA() != TStreamerArtificial::Class()
                      || nextel->GetType() == TStreamerInfo::kCacheDelete ) {
                     break;
                  }
                  fIDs.push_back(i);
               }
            } else if (elt && offset==TStreamerInfo::kMissing) {
               // Still re-assign fID properly.
               fIDs.clear();
               size_t ndata = fInfo->GetNelement();
               for (size_t i = 0; i < ndata; ++i) {
                  if (fInfo->GetElement(i) == elt) {
                     fID = i;
                     break;
                  }
               }
            } else {
               // We have not even found the element .. this is strange :(
               // fIDs.clear();
               // fID = -3;
               // SetBit(kDoNotProcess);
            }
            if (fOnfileObject==0 && (fType==31 || fType==41 || (0 <= fType && fType <=2) ) && fInfo->GetNelement()
                && fInfo->GetElement(0)->GetType() == TStreamerInfo::kCacheNew)
            {
               Int_t arrlen = 1;
               if (fType==31 || fType==41) {
                  TLeaf *leaf = (TLeaf*)fLeaves.At(0);
                  if (leaf) {
                     arrlen = leaf->GetMaximum();
                  }
               }
               fOnfileObject = new TVirtualArray( fInfo->GetElement(0)->GetClassPointer(), arrlen );
               // Propage this to all the other branch of this type.
               TObjArray *branches = GetMother()->GetSubBranch(this)->GetListOfBranches();
               Int_t nbranches = branches->GetEntriesFast();
               TBranchElement *lastbranch = this;
               for (Int_t i = 0; i < nbranches; ++i) {
                  TBranchElement* subbranch = (TBranchElement*)branches->At(i);
                  if (this!=subbranch && subbranch->fBranchClass == fBranchClass && subbranch->fCheckSum == fCheckSum) {
                     subbranch->fOnfileObject = fOnfileObject;
                     lastbranch = subbranch;
                  }
               }
               lastbranch->SetBit(kOwnOnfileObj);
            }
         }
         fInit = kTRUE;

         // Get the action sequence we need to copy for reading.
         SetReadActionSequence();
         SetFillActionSequence();
      } else if (!fReadActionSequence) {
         // Get the action sequence we need to copy for reading.
         SetReadActionSequence();
         SetFillActionSequence();
      }
      SetReadLeavesPtr();
      SetFillLeavesPtr();
   }
}

//______________________________________________________________________________
TVirtualCollectionProxy* TBranchElement::GetCollectionProxy()
{
   // -- Return the collection proxy describing the branch content, if any.

   if (fCollProxy) {
      return fCollProxy;
   }
   TBranchElement* thiscast = const_cast<TBranchElement*>(this);
   if (fType == 4) {
      // STL container top-level branch.
      const char* className = 0;
      if (fID < 0) {
         // We are a top-level branch.
         if (fBranchClass.GetClass()) {
            className = fBranchClass.GetClass()->GetName();
         }
      } else {
         // We are not a top-level branch.
         TVirtualStreamerInfo* si = thiscast->GetInfoImp();
         TStreamerElement* se = si->GetElement(fID);
         className = se->GetTypeName();
      }
      TClass* cl = className ? TClass::GetClass(className) : 0;
      if (!cl) {
         // The TClass was not created but we do know (since it
         // is used as a collection) that it 'className' was a
         // class, so let's create it by hand!.

         if (fID < 0) {
            cl = new TClass(fBranchClass.GetClassName(), fClassVersion);
            cl->SetBit(TClass::kIsEmulation);
            className = cl->GetName();
         } else {
            cl = new TClass(className, fClassVersion);
            cl->SetBit(TClass::kIsEmulation);
            className = cl->GetName();
         }
      }
      TVirtualCollectionProxy* proxy = cl->GetCollectionProxy();
      if (!proxy) {
         // humm, we must have an older file with a custom collection
         // let's try to work-around it.
         TString equiv;
         equiv.Form("vector<%s>",fClonesName.Data());
         TClass *clequiv = TClass::GetClass(equiv);
         proxy = clequiv->GetCollectionProxy();
         if (!proxy) {
            Fatal("GetCollectionProxy",
                  "Can not create a Collection Proxy of any kind for the class \"%s\" needed by the branch \"%s\" of the TTree \"%s\"!",
                  className, GetName(), GetTree()->GetName());
         }
         if (gDebug > 0) Info("GetCollectionProxy",
                              "Fixing the collection proxy of the class \"%s\" \n"
                              "\tneeded by the branch \"%s\" of the TTree \"%s\" to be similar to \"%s\".",
                              className, GetName(), GetTree()->GetName(),equiv.Data());
         cl->CopyCollectionProxy( *proxy );
      }
      fCollProxy = proxy->Generate();
      fSTLtype = proxy->GetCollectionType();
   } else if (fType == 41) {
      // STL container sub-branch.
      thiscast->fCollProxy = fBranchCount->GetCollectionProxy();
   }
   return fCollProxy;
}

//______________________________________________________________________________
TClass* TBranchElement::GetCurrentClass()
{
   // -- Return a pointer to the current type of the data member corresponding to branch element.

   TClass* cl = fCurrentClass;
   if (cl) {
      return cl;
   }

   TStreamerInfo* brInfo = (TStreamerInfo*)GetInfoImp();
   if (!brInfo) {
      cl = TClass::GetClass(GetClassName());
      R__ASSERT(cl && cl->GetCollectionProxy());
      fCurrentClass = cl;
      return cl;
   }
   TClass* motherCl = brInfo->GetClass();
   if (motherCl->GetCollectionProxy()) {
      cl = motherCl->GetCollectionProxy()->GetCollectionClass();
      if (cl) {
         fCurrentClass = cl;
      }
      return cl;
   }
   if (GetID() < 0 || GetID()>=brInfo->GetNelement()) {
      return 0;
   }
   TStreamerElement* currentStreamerElement = brInfo->GetElement(GetID());
   TDataMember* dm = (TDataMember*) motherCl->GetListOfDataMembers()->FindObject(currentStreamerElement->GetName());

   TString newType;
   if (!dm) {
      // Either the class is not loaded or the data member is gone
      if (!motherCl->IsLoaded()) {
         TVirtualStreamerInfo* newInfo = motherCl->GetStreamerInfo();
         if (newInfo != brInfo) {
            TStreamerElement* newElems = (TStreamerElement*) newInfo->GetElements()->FindObject(currentStreamerElement->GetName());
            if (newElems) {
               newType = newElems->GetClassPointer()->GetName();
            }
         }
         if (newType.Length()==0) {
            newType = currentStreamerElement->GetClassPointer()->GetName();
         }
      }
   } else {
      newType = dm->GetTypeName();
   }
   cl = TClass::GetClass(newType);
   if (cl) {
      fCurrentClass = cl;
   }
   return cl;
}

//______________________________________________________________________________
Int_t TBranchElement::GetEntry(Long64_t entry, Int_t getall)
{
   // -- Read all branches of a BranchElement and return total number of bytes.
   //
   // If entry = 0, then use current entry number + 1.
   // If entry < 0, then reset entry number to 0.
   //
   // Returns the number of bytes read from the input buffer.
   // If entry does not exist, then returns 0.
   // If an I/O error occurs, then returns -1.
   //
   // See IMPORTANT REMARKS in TTree::GetEntry.
   //

   // Remember which entry we are reading.
   fReadEntry = entry;

   // If our tree has a branch ref, make it remember the entry and
   // this branch.  This allows a TRef::GetObject() call done during
   // the following I/O operation, for example in a custom streamer,
   // to search for the referenced object in the proper element of the
   // proper branch.
   TBranchRef* bref = fTree->GetBranchRef();
   if (R__unlikely(bref)) {
      fBranchID = bref->SetParent(this, fBranchID);
      bref->SetRequestedEntry(entry);
   }

   Int_t nbytes = 0;

   if (R__unlikely(IsAutoDelete())) {
      SetBit(kDeleteObject);
      SetAddress(fAddress);
   } else {
      if (R__unlikely(!fAddress && !fTree->GetMakeClass())) {
         SetupAddressesImpl();
      }
   }

   Int_t nbranches = fBranches.GetEntriesFast();
   if (nbranches) {
      // -- Branch has daughters.
      // One must always read the branch counter.
      // In the case when one reads consecutively twice the same entry,
      // the user may have cleared the TClonesArray between the GetEntry calls.
      if ((fType == 3) || (fType == 4)) {
         Int_t nb = TBranch::GetEntry(entry, getall);
         if (nb < 0) {
            return nb;
         }
         nbytes += nb;
      }
      switch(fSTLtype) {
         case ROOT::kSTLset:
         case ROOT::kSTLmultiset:
         case ROOT::kSTLunorderedset:
         case ROOT::kSTLunorderedmultiset:
         case ROOT::kSTLmap:
         case ROOT::kSTLmultimap:
         case ROOT::kSTLunorderedmap:
         case ROOT::kSTLunorderedmultimap:
            break;
         default:
            ValidateAddress(); // There is no ReadLeave for this node, so we need to do the validation here.
            for (Int_t i = 0; i < nbranches; ++i) {
               TBranch* branch = (TBranch*) fBranches.UncheckedAt(i);
               Int_t nb = branch->GetEntry(entry, getall);
               if (nb < 0) {
                  return nb;
               }
               nbytes += nb;
            }
            break;
      }
   } else {
      // -- Terminal branch.
      if (fBranchCount && (fBranchCount->GetReadEntry() != entry)) {
         Int_t nb = fBranchCount->TBranch::GetEntry(entry, getall);
         if (nb < 0) {
            return nb;
         }
         nbytes += nb;
      }
      Int_t nb = TBranch::GetEntry(entry, getall);
      if (nb < 0) {
         return nb;
      }
      nbytes += nb;
   }

   if (R__unlikely(fTree->Debug() > 0)) {
      if ((entry >= fTree->GetDebugMin()) && (entry <= fTree->GetDebugMax())) {
         Info("GetEntry", "%lld, branch=%s, nbytes=%d", entry, GetName(), nbytes);
      }
   }
   return nbytes;
}

//______________________________________________________________________________
Int_t TBranchElement::GetExpectedType(TClass *&expectedClass,EDataType &expectedType)
{
   // Fill expectedClass and expectedType with information on the data type of the
   // object/values contained in this branch (and thus the type of pointers
   // expected to be passed to Set[Branch]Address
   // return 0 in case of success and > 0 in case of failure.

   expectedClass = 0;
   expectedType = kOther_t;

   Int_t type = GetStreamerType();
   if ((type == -1) || (fID == -1)) {
      expectedClass = fBranchClass;
   } else {
      // Case of an object data member.  Here we allow for the
      // variable name to be ommitted.  Eg, for Event.root with split
      // level 1 or above  Draw("GetXaxis") is the same as Draw("fH.GetXaxis()")
      TStreamerElement* element = GetInfoImp()->GetElement(fID);
      if (element) {
         expectedClass = element->GetClassPointer();
         if (!expectedClass) {
            TDataType* data = gROOT->GetType(element->GetTypeNameBasic());
            if (!data) {
               Error("GetExpectedType", "Did not find the type number for %s", element->GetTypeNameBasic());
               return 1;
            } else {
               expectedType = (EDataType) data->GetType();
            }
         }
      } else {
         Error("GetExpectedType", "Did not find the type for %s",GetName());
         return 2;
      }
   }
   return 0;
}

//______________________________________________________________________________
const char* TBranchElement::GetIconName() const
{
   // -- Return icon name depending on type of branch element.

   if (IsFolder()) {
      return "TBranchElement-folder";
   } else {
      return "TBranchElement-leaf";
   }
}

//______________________________________________________________________________
Bool_t TBranchElement::GetMakeClass() const
{
   // Return whether this branch is in a mode where the object are decomposed
   // or not (Also known as MakeClass mode).

   return TestBit(kDecomposedObj); // Same as TestBit(kMakeClass)
}

//______________________________________________________________________________
Int_t TBranchElement::GetMaximum() const
{
   // -- Return maximum count value of the branchcount if any.

   if (fBranchCount) {
      return fBranchCount->GetMaximum();
   }
   return fMaximum;
}

//______________________________________________________________________________
char* TBranchElement::GetObject() const
{
   // -- Return a pointer to our object.

   ValidateAddress();
   return fObject;
}

//______________________________________________________________________________
TClass* TBranchElement::GetParentClass()
{
   // -- Return a pointer to the parent class of the branch element.
   return fParentClass.GetClass();
}

//______________________________________________________________________________
const char* TBranchElement::GetTypeName() const
{
   // -- Return type name of element in the branch.

   if (fType == 3  || fType == 4) {
      return "Int_t";
   }
   // FIXME: Use symbolic constants here.
   if ((fStreamerType < 1) || (fStreamerType > 59)) {
      if (fBranchClass.GetClass()) {
         if (fID>=0) {
            return GetInfoImp()->GetElement(fID)->GetTypeName();
         } else {
            return fBranchClass.GetClass()->GetName();
         }
      } else {
         return 0;
      }
   }
   const char *types[20] = {
      "",
      "Char_t",
      "Short_t",
      "Int_t",
      "Long_t",
      "Float_t",
      "Int_t",
      "char*",
      "Double_t",
      "Double32_t",
      "",
      "UChar_t",
      "UShort_t",
      "UInt_t",
      "ULong_t",
      "UInt_t",
      "Long64_t",
      "ULong64_t",
      "Bool_t",
      "Float16_t"
   };
   Int_t itype = fStreamerType % 20;
   return types[itype];
}

//______________________________________________________________________________
template Double_t TBranchElement::GetTypedValue(Int_t j, Int_t len, Bool_t subarr) const;
template Long64_t TBranchElement::GetTypedValue(Int_t j, Int_t len, Bool_t subarr) const;
template LongDouble_t TBranchElement::GetTypedValue(Int_t j, Int_t len, Bool_t subarr) const;

template <typename T>
T TBranchElement::GetTypedValue(Int_t j, Int_t len, Bool_t subarr) const
{
   // -- Returns the branch value.
   //
   // If the leaf is an array, j is the index in the array.
   //
   // If leaf is an array inside a TClonesArray, len should be the length
   // of the array.
   //
   // If subarr is true, then len is actually the index within the sub-array.
   //

   ValidateAddress();

   Int_t prID = fID;
   char *object = fObject;
   if (TestBit(kCache)) {
      if (GetInfoImp()->GetElements()->At(fID)->TestBit(TStreamerElement::kRepeat)) {
         prID = fID+1;
      } else if (fOnfileObject) {
         object = fOnfileObject->GetObjectAt(0);
      }
   }

   if (!j && fBranchCount) {
      Long64_t entry = fTree->GetReadEntry();
      // Since reloading the index, will reset the ClonesArray, let's
      // skip the load if we already read this entry.
      if (entry != fBranchCount->GetReadEntry()) {
         fBranchCount->TBranch::GetEntry(entry);
      }
      if (fBranchCount2 && entry != fBranchCount2->GetReadEntry()) {
         fBranchCount2->TBranch::GetEntry(entry);
      }
   }

   if (fTree->GetMakeClass()) {
      if (!fAddress) {
         return 0;
      }
      if ((fType == 3) || (fType == 4)) {
         // Top-level branch of a TClonesArray.
         return fNdata;
      } else if ((fType == 31) || (fType == 41)) {
         // sub branch of a TClonesArray
         Int_t atype = fStreamerType;
         if (atype < 20) {
            atype += 20;
         }
         return GetInfoImp()->GetTypedValue<T>(fAddress, atype, j, 1);
      } else if (fType <= 2) {
         // branch in split mode
         // FIXME: This should probably be < 60 instead!
         if ((fStreamerType > 40) && (fStreamerType < 55)) {
            Int_t atype = fStreamerType - 20;
            return GetInfoImp()->GetTypedValue<T>(fAddress, atype, j, 1);
         } else {
            return GetInfoImp()->GetTypedValue<T>(object, prID, j, -1);
         }
      }
   }

   if (object == 0)
   {
      // We have nowhere to read the data from (probably because the data member was
      // 'dropped' from the current schema).
      return 0;
   }

   if (fType == 31) {
      TClonesArray* clones = (TClonesArray*) object;
      if (subarr) {
         return GetInfoImp()->GetTypedValueClones<T>(clones, prID, j, len, fOffset);
      }
      return GetInfoImp()->GetTypedValueClones<T>(clones, prID, j/len, j%len, fOffset);
   } else if (fType == 41) {
      TVirtualCollectionProxy::TPushPop helper(((TBranchElement*) this)->GetCollectionProxy(), object);
      if( fSplitLevel < TTree::kSplitCollectionOfPointers )
      {
         if (subarr)
            return GetInfoImp()->GetTypedValueSTL<T>(((TBranchElement*) this)->GetCollectionProxy(), prID, j, len, fOffset);

         return GetInfoImp()->GetTypedValueSTL<T>(((TBranchElement*) this)->GetCollectionProxy(), prID, j/len, j%len, fOffset);
      }
      else
      {
         if (subarr)
            return GetInfoImp()->GetTypedValueSTLP<T>(((TBranchElement*) this)->GetCollectionProxy(), prID, j, len, fOffset);
         return GetInfoImp()->GetTypedValueSTLP<T>(((TBranchElement*) this)->GetCollectionProxy(), prID, j/len, j%len, fOffset);
      }
   } else {
      if (GetInfoImp()) {
         return GetInfoImp()->GetTypedValue<T>(object, prID, j, -1);
      }
      return 0;
   }
}

//______________________________________________________________________________
void* TBranchElement::GetValuePointer() const
{
   // -- Returns pointer to first data element of this branch.
   // Currently used only for members of type character.

   ValidateAddress();

   Int_t prID = fID;
   char *object = fObject;
   if (TestBit(kCache)) {
      if (GetInfoImp()->GetElements()->At(fID)->TestBit(TStreamerElement::kRepeat)) {
         prID = fID+1;
      } else if (fOnfileObject) {
         object = fOnfileObject->GetObjectAt(0);
      }
   }

   if (fBranchCount) {
      Long64_t entry = fTree->GetReadEntry();
      fBranchCount->TBranch::GetEntry(entry);
      if (fBranchCount2) fBranchCount2->TBranch::GetEntry(entry);
   }
   if (fTree->GetMakeClass()) {
      if (!fAddress) {
         return 0;
      }
      if (fType == 3) {    //top level branch of a TClonesArray
                           //return &fNdata;
         return 0;
      } else if (fType == 4) {    //top level branch of a TClonesArray
                                  //return &fNdata;
         return 0;
      } else if (fType == 31) {    // sub branch of a TClonesArray
                                   //Int_t atype = fStreamerType;
                                   //if (atype < 20) atype += 20;
                                   //return GetInfoImp()->GetValue(fAddress, atype, j, 1);
         return 0;
      } else if (fType == 41) {    // sub branch of a TClonesArray
                                   //Int_t atype = fStreamerType;
                                   //if (atype < 20) atype += 20;
                                   //return GetInfoImp()->GetValue(fAddress, atype, j, 1);
         return 0;
      } else if (fType <= 2) {     // branch in split mode
                                   // FIXME: This should probably be < 60 instead!
         if (fStreamerType > 40 && fStreamerType < 55) {
            //Int_t atype = fStreamerType - 20;
            //return GetInfoImp()->GetValue(fAddress, atype, j, 1);
            return 0;
         } else {
            //return GetInfoImp()->GetValue(object, fID, j, -1);
            return 0;
         }
      }
   }

   if (fType == 31) {
      return 0;
   } else if (fType == 41) {
      return 0;
   } else if (prID < 0) {
      return object;
   } else {
      //return GetInfoImp()->GetValue(object,fID,j,-1);
      if (!GetInfoImp() || !object) return 0;
      char **val = (char**)(object+GetInfoImp()->TStreamerInfo::GetElementOffset(prID));
      return *val;
   }
}

//______________________________________________________________________________
void TBranchElement::InitializeOffsets()
{
   // -- Initialize the base class subobjects offsets of our sub-branches and set fOffset if we are a container sub-branch.
   //
   // Note: The offsets are zero for data members so that when
   //       SetAddress recursively sets their address, they will get the
   //       same address as their containing class because i/o is based
   //       on streamer info offsets from the addresss of the containing
   //       class.
   //
   //       Offsets are non-zero for base-class sub-branches that are
   //       not the leftmost direct base class.  They are laid out in
   //       memory sequentially and only the leftmost direct base class
   //       has the same address as the derived class.  The streamer
   //       offsets need to be added to the address of the base class
   //       subobject which is not the same as the address of the
   //       derived class for the non-leftmost direct base classes.

   Int_t nbranches = fBranches.GetEntriesFast();

   if (fID < 0) {
      // -- We are a top-level branch.  Let's mark whether we need to use MapObject.
      if (CanSelfReference(fBranchClass)) {
         if (fBranchClass.GetClass()->IsTObject()) {
            SetBit(kBranchObject);
         } else {
            SetBit(kBranchAny);
         }
      }
   }
   if (nbranches) {
      // Allocate space for the new sub-branch offsets.
      delete[] fBranchOffset;
      fBranchOffset = 0;
      fBranchOffset = new Int_t[nbranches];
      // Make sure we can instantiate our class meta info.
      if (!fBranchClass.GetClass()) {
         Warning("InitializeOffsets", "No branch class set for branch: %s", GetName());
         fInitOffsets = kTRUE;
         return;
      }
      // Make sure we can instantiate our class streamer info.
      if (!GetInfoImp()) {
         Warning("InitializeOffsets", "No streamer info available for branch: %s of class: %s", GetName(), fBranchClass.GetClass()->GetName());
         fInitOffsets = kTRUE;
         return;
      }

      // Get the class we are a member of now (which is the
      // type of our containing subobject) and get our offset
      // inside of our containing subobject (our local offset).
      // Note: branchElem stays zero if we are a top-level branch,
      //       we have to be careful about this later.
      TStreamerElement* branchElem = 0;
      Int_t localOffset = 0;
      TClass* branchClass = fBranchClass.GetClass();
      Bool_t renamed = kFALSE;
      if (fID > -1) {
         // -- Branch is *not* a top-level branch.
         // Instead of the streamer info class, we want the class of our
         // specific element in the streamer info.  We could be a data
         // member of a base class or a split class, in which case our
         // streamer info will be for our containing sub-object, while
         // we are actually a different type.
         TVirtualStreamerInfo* si = GetInfoImp();
         // Note: We tested to make sure the streamer info was available previously.
         if (!si->IsCompiled()) {
            Warning("InitializeOffsets", "Streamer info for branch: %s has no elements array!", GetName());
            fInitOffsets = kTRUE;
            return;
         }
         // FIXME: Check that fID is in range.
         branchElem = si->GetElement(fID);
         if (!branchElem) {
            Warning("InitializeOffsets", "Cannot get streamer element for branch: %s!", GetName());
            fInitOffsets = kTRUE;
            return;
         } else if (branchElem->TestBit(TStreamerElement::kRepeat)) {
            // If we have a repeating streamerElement, use the next
            // one as it actually hold the 'real' data member('s offset)
            if (si->GetElement(fID+1)) {
               branchElem = si->GetElement(fID+1);
            }
         }
         localOffset = branchElem->GetOffset();
         branchClass = branchElem->GetClassPointer();
         if (localOffset == TStreamerInfo::kMissing) {
            fObject = 0;
         } else {
            renamed = branchClass && branchElem->GetNewClass() && (branchClass != branchElem->GetNewClass());
         }
      } else {
         renamed = fTargetClass != fBranchClass;
      }
      if (!branchClass) {
         Error("InitializeOffsets", "Could not find class for branch: %s", GetName());
         fInitOffsets = kTRUE;
         return;
      }

      //------------------------------------------------------------------------
      // Extract the name of the STL branch in case it has been split.
      //------------------------------------------------------------------------
      TString stlParentName;
      Bool_t stlParentNameUpdated = kFALSE;
      if( fType == 4 )
      {
         TBranch *br = GetMother()->GetSubBranch( this );
         stlParentName = br->GetName();
         stlParentName.Strip( TString::kTrailing, '.' );

         // We may ourself contain the 'Mother' branch name.
         // To avoid code duplication, we delegate the removal
         // of the mother's name to the first sub-branch loop.
      }

      // Loop over our sub-branches and compute their offsets.
      for (Int_t subBranchIdx = 0; subBranchIdx < nbranches; ++subBranchIdx) {
         bool alternateElement = false;

         fBranchOffset[subBranchIdx] = 0;
         TBranchElement* subBranch = dynamic_cast<TBranchElement*> (fBranches[subBranchIdx]);
         if (subBranch == 0) {
            // -- Skip sub-branches that are not TBranchElements.
            continue;
         }

         if (renamed) {
            if (subBranch->fBranchClass == branchClass) {
               if (branchElem) subBranch->SetTargetClass(branchElem->GetNewClass()->GetName());
               else subBranch->SetTargetClass(fTargetClass->GetName());
            }
         }

         TVirtualStreamerInfo* sinfo = subBranch->GetInfoImp();
         if (!sinfo) {
            Warning("InitializeOffsets", "No streamer info for branch: %s subbranch: %s", GetName(), subBranch->GetName());
            fBranchOffset[subBranchIdx] = TStreamerInfo::kMissing;
            continue;
         }
         if (!sinfo->IsCompiled()) {
            Warning("InitializeOffsets", "No elements array for branch: %s subbranch: %s", GetName(), subBranch->GetName());
            fBranchOffset[subBranchIdx] = TStreamerInfo::kMissing;
            continue;
         }
         // FIXME: Make sure subBranch->fID is in range.
         TStreamerElement* subBranchElement = sinfo->GetElement(subBranch->fID);
         if (!subBranchElement) {
            Warning("InitializeOffsets", "No streamer element for branch: %s subbranch: %s", GetName(), subBranch->GetName());
            fBranchOffset[subBranchIdx] = TStreamerInfo::kMissing;
            continue;
         } else if (subBranchElement->TestBit(TStreamerElement::kRepeat)) {
            // If we have a repeating streamerElement, use the next
            // one as it actually hold the 'real' data member('s offset)
            if (sinfo->GetElement(subBranch->fID+1)) {
               subBranchElement = sinfo->GetElement(subBranch->fID+1);
            }
         } else if (subBranchElement->TestBit(TStreamerElement::kCache)) {
            // We have a cached item which is not a repeated but we might still
            // have some Actions triggered by a rule that affect real
            // data member(s).
            if (subBranch->fReadActionSequence && subBranch->fReadActionSequence->fActions.size() > 1) {
               typedef TStreamerInfoActions::ActionContainer_t::iterator iterator;
               iterator end = subBranch->fReadActionSequence->fActions.end();
               for(iterator iter = subBranch->fReadActionSequence->fActions.begin();
                   iter != end; ++iter) {
                  TStreamerInfoActions::TConfiguration *config = iter->fConfiguration;
                  UInt_t id = config->fElemId;
                  TStreamerElement *e = (TStreamerElement*)config->fInfo->GetElements()->At(id);
                  if (e && !e->TestBit(TStreamerElement::kCache)) {
                     subBranchElement = e;
                     alternateElement = true;
                     break;
                  }
               }
            }
         }

         localOffset = subBranchElement->GetOffset();
         if (localOffset == TStreamerInfo::kMissing) {
            subBranch->fObject = 0;
         }

         {
            Int_t streamerType = subBranchElement->GetType();
            if (streamerType > TStreamerInfo::kObject
                && subBranch->GetListOfBranches()->GetEntries()==0
                && CanSelfReference(subBranchElement->GetClass()))
            {
               subBranch->SetBit(kBranchAny);
            } else {
               subBranch->ResetBit(kBranchAny);
            }
         }

         if (subBranchElement->GetNewType()<0) {
            subBranch->ResetBit(kBranchAny);
            subBranch->ResetBit(kBranchObject);
         }

         // Note: This call is expensive, do it only once.
         TBranch* mother = GetMother();
         if (!mother) {
            Warning("InitializeOffsets", "Branch '%s' has no mother!", GetName());
            fBranchOffset[subBranchIdx] = TStreamerInfo::kMissing;
            continue;
         }
         TString motherName(mother->GetName());
         Bool_t motherDot = kFALSE;
         if (motherName.Length() && strchr(motherName.Data(), '.')) {
            motherDot = kTRUE;
         }
         Bool_t motherDotAtEnd = kFALSE;
         if (motherName.Length() && (motherName[motherName.Length()-1] == '.')) {
            motherDotAtEnd = kTRUE;
         }

         Bool_t isBaseSubBranch = kFALSE;
         if ((subBranch->fType == 1) || (subBranchElement && subBranchElement->IsBase())) {
            // -- Base class sub-branch (1).
            //
            // Note: Our type will not be 1, even though we are
            // a base class branch, if we are not split (see the
            // constructor), or if we are an STL container master
            // branch and a base class branch at the same time
            // or an std::string.
            isBaseSubBranch = kTRUE;
         }

         Bool_t isContDataMember = kFALSE;
         if ((subBranch->fType == 31) || (subBranch->fType == 41)) {
            // -- Container data member sub-branch (31 or 41).
            isContDataMember = kTRUE;
         }

         // I am either a data member sub-branch (0), or a base class
         // sub-branch (1), or TClonesArray master sub-branch (3),
         // or an STL container master sub-branch (4), or TClonesArray
         // data member sub-branch (31), or an STL container data member
         // sub-branch (41).
         //
         // My parent branch is either a top-level branch ((0), fID==(-2,-1)),
         // or a base class sub-branch (1), or a split-class branch (2),
         // or a TClonesArray master branch (3), or an STL container
         // master branch (4).
         //

         //
         // We need to extract from our name the name
         // of the data member which contains us, so
         // that we may then do a by-name lookup in the
         // dictionary meta info of our parent class to
         // get our offset in our parent class.
         //

         // Get our name.
         TString dataName(subBranch->GetName());
         if (motherDotAtEnd) {
            // -- Remove the top-level branch name from our name.
            dataName.Remove(0, motherName.Length());
            // stlParentNameUpdated is false the first time in this loop.
            if (!stlParentNameUpdated && stlParentName.Length()) {
               stlParentName.Remove(0, motherName.Length());
               stlParentNameUpdated = kTRUE;
            }
         } else if (motherDot) {
            // -- Remove the top-level branch name from our name, folder case.
            //
            // Note: We are in the case where our mother was created
            //       by the branch constructor which takes a folder
            //       as an argument.  The mother branch has internal
            //       dots in its name to represent the folder heirarchy.
            //       The TTree::Bronch() routine has handled us as a
            //       special case, we must compensate.
            if ((fID < 0) && (subBranchElement->IsA() == TStreamerBase::Class())) {
               // -- Our name is the mother name, remove it.
               // Note: The test is our parent is a top-level branch
               //       and our streamer is the base class streamer,
               //       this matches the exact test in TTree::Bronch().
               if (dataName.Length() == motherName.Length()) {
                  dataName.Remove(0, motherName.Length());
                  // stlParentNameUpdated is false the first time in this loop.
                  if (!stlParentNameUpdated && stlParentName.Length()) {
                     stlParentName.Remove(0, motherName.Length());
                  }
               }
            } else {
               // -- Remove the mother name and the dot.
               if (dataName.Length() > motherName.Length()) {
                  dataName.Remove(0, motherName.Length() + 1);
                  if (!stlParentNameUpdated && stlParentName.Length()) {
                     stlParentName.Remove(0, motherName.Length());
                  }
               }
            }
         }
         stlParentNameUpdated = kTRUE;
         if (isBaseSubBranch) {
            // -- Remove the base class name suffix from our name.
            // Note: The pattern is the name of the base class.
            TString pattern(subBranchElement->GetName());
            if (pattern.Length() <= dataName.Length()) {
               if (!strcmp(dataName.Data() + (dataName.Length() - pattern.Length()), pattern.Data())) {
                  // The branch name contains the name of the base class in it.
                  // This name is not reproduced in the sub-branches, so we need to
                  // remove it.
                  dataName.Remove(dataName.Length() - pattern.Length());
               }
            }
            // Remove any leading dot.
            if (dataName.Length()) {
               if (dataName[0] == '.') {
                  dataName.Remove(0, 1);
               }
            }
            // Note: We intentionally leave any trailing dot
            //       in our modified name here.
         }

         // Get our parent branch's name.
         TString parentName(GetName());
         if (motherDotAtEnd) {
            // -- Remove the top-level branch name from our parent's name.
            parentName.Remove(0, motherName.Length());
         } else if (motherDot) {
            // -- Remove the top-level branch name from our parent's name, folder case.
            //
            // Note: We are in the case where our mother was created
            //       by the branch constructor which takes a folder
            //       as an argument.  The mother branch has internal
            //       dots in its name to represent the folder heirarchy.
            //       The TTree::Bronch() routine has handled us as a
            //       special case, we must compensate.
            if ((fID > -1) && (mother == mother->GetSubBranch(this)) && (branchElem->IsA() == TStreamerBase::Class())) {
               // -- Our parent's name is the mother name, remove it.
               // Note: The test is our parent's parent is a top-level branch
               //       and our parent's streamer is the base class streamer,
               //       this matches the exact test in TTree::Bronch().
               if (parentName.Length() == motherName.Length()) {
                  parentName.Remove(0, motherName.Length());
               }
            } else {
               // -- Remove the mother name and the dot.
               if (parentName.Length() > motherName.Length()) {
                  parentName.Remove(0, motherName.Length() + 1);
               }
            }
         }
         // FIXME: Do we need to use the other tests for a base class here?
         if (fType == 1) {
            // -- Our parent is a base class sub-branch, remove the base class name suffix from its name.
            if (mother != mother->GetSubBranch(this)) {
               // -- My parent's parent is not a top-level branch.
               // Remove the base class name suffix from the parent name.
               // Note: The pattern is the name of the base class.
               // coverity[var_deref_model] branchElem is non zero here since fType==1 and thus fID > -1
               TString pattern(branchElem->GetName());
               if (pattern.Length() <= parentName.Length()) {
                  if (!strcmp(parentName.Data() + (parentName.Length() - pattern.Length()), pattern.Data())) {
                     // The branch name contains the name of the base class in it.
                     // This name is not reproduced in the sub-branches, so we need to
                     // remove it.
                     parentName.Remove(parentName.Length() - pattern.Length());
                  }
               }
            }
            // Note: We intentionally leave any trailing dots
            //       in the modified parent name here.
         }

         // Remove the parent branch name part from our name,
         // but only if the parent branch is not a top-level branch.
         // FIXME: We should not assume parent name does not have length 0.
         if (fID > -1) {
            RemovePrefix(dataName, parentName);
         }

         // Remove any leading dot.
         if (dataName.Length()) {
            if (dataName[0] == '.') {
               dataName.Remove(0, 1);
            }
         }

         // Remove any trailing dot.
         if (dataName.Length()) {
            if (dataName[dataName.Length()-1] == '.') {
               dataName.Remove(dataName.Length() - 1, 1);
            }
         }

         //
         // Now that we have our data member name, find our offset
         // in our parent class.
         //
         // Note:  Our data member name can have many dots in it
         //        if branches were elided between our parent branch
         //        and us by Unroll().
         //
         // FIXME: This may not work if our member name is ambiguous.
         //

         Int_t offset = 0;
         if (dataName.Length()) {
            // -- We have our data member name, do a lookup in the dictionary meta info of our parent class.
            // Get our parent class.
            TClass* pClass = 0;
            // First check whether this sub-branch is part of the 'cache' (because the data member it
            // represents is no longer in the current class layout.
            TStreamerInfo *subInfo = subBranch->GetInfoImp();
            //if (subInfo && subBranch->TestBit(kCache)) { // subInfo->GetElements()->At(subBranch->GetID())->TestBit(TStreamerElement::kCache)) {
            if (subBranchElement->TestBit(TStreamerElement::kCache)) {
               pClass = ((TStreamerElement*)subInfo->GetElements()->At(0))->GetClassPointer();
            }
            // FIXME: Do we need the other base class tests here?
            if (!pClass) {
               if (fType == 1) {
                  // -- Parent branch is a base class branch.
                  // FIXME: Is using branchElem here the right thing?
                  pClass = branchElem->GetClassPointer();
                  if (pClass->Property() & kIsAbstract) {
                     // the class is abstract, let see if the

                     TBranchElement *parent = (TBranchElement*)GetMother()->GetSubBranch(this);
                     if (parent && parent != this && !parent->GetClass()->IsLoaded() ) {
                        // Our parent's class is emulated and we represent an abstract class.
                        // and the target class has not been set explicilty.
                        TString target = pClass->GetName();
                        target += "@@emulated";

                        pClass = TClass::GetClass(target);
                     }
                  }
               } else {
                  // -- Parent branch is *not* a base class branch.
                  // FIXME: This sometimes returns a null pointer.
                  pClass = subBranch->GetParentClass();
               }
            }
            if (!pClass) {
               // -- No parent class, fix it.
               // FIXME: This is probably wrong!
               // Assume parent class is our parent branch's clones class or value class.
               if (GetClonesName() && strlen(GetClonesName())) {
                  pClass = fClonesClass;
                  if (!pClass) {
                     Warning("InitializeOffsets", "subBranch: '%s' has no parent class, and cannot get class for clones class: '%s'!", subBranch->GetName(), GetClonesName());
                     fBranchOffset[subBranchIdx] = TStreamerInfo::kMissing;
                     continue;
                 }
                  Warning("InitializeOffsets", "subBranch: '%s' has no parent class!  Assuming parent class is: '%s'.", subBranch->GetName(), pClass->GetName());
               }
               if (fBranchCount && fBranchCount->fCollProxy && fBranchCount->fCollProxy->GetValueClass()) {
                  pClass = fBranchCount->fCollProxy->GetValueClass();
                  Warning("InitializeOffsets", "subBranch: '%s' has no parent class!  Assuming parent class is: '%s'.", subBranch->GetName(), pClass ? pClass->GetName() : "unknowned class");
               }
               if (!pClass) {
                  // -- Still no parent class, assume our parent class is our parent branch's class.
                  // FIXME: This is probably wrong!
                  pClass = branchClass;
                  // FIXME: Enable this warning!
                  //Warning("InitializeOffsets", "subBranch: '%s' has no parent class!  Assuming parent class is: '%s'.", subBranch->GetName(), pClass->GetName());
               }
            }
            if (renamed && pClass) {
               if (pClass == branchClass) {
                  pClass = branchElem->GetNewClass();
               } else if (fCollProxy && pClass == branchClass->GetCollectionProxy()->GetValueClass()) {
                  pClass = fCollProxy->GetValueClass();
               }
            }

            //------------------------------------------------------------------
            // If we have the are the sub-branch of the TBranchSTL, we need
            // to remove it's name to get the correct real data offsets
            //-----------------------------------------------------------------
            if( dynamic_cast<TBranchSTL*>(fParent) && stlParentName.Length() )
            {
               if( !strncmp( stlParentName.Data(), dataName.Data(), stlParentName.Length()-1 )
                  && dataName[ stlParentName.Length() ] == '.' )
                  dataName.Remove( 0, stlParentName.Length()+1 );
            }

            // Find our offset in our parent class using
            // a lookup by name in the dictionary meta info
            // for our parent class.

            if (alternateElement) {
               Ssiz_t dotpos = dataName.Last('.');
               Ssiz_t endpos = dataName.Length();
               if (dotpos != kNPOS) ++dotpos; else dotpos = 0;
               dataName.Replace(dotpos,endpos-dotpos,subBranchElement->GetFullName());
            }
            TRealData* rd = pClass->GetRealData(dataName);
            if (rd && (!rd->TestBit(TRealData::kTransient) || alternateElement)) {
               // -- Data member exists in the dictionary meta info, get the offset.
               // If we are using an alternateElement, it is the target of a rule
               // and might be indeed transient.
               offset = rd->GetThisOffset();
            } else if (subBranchElement->TestBit(TStreamerElement::kWholeObject)) {
               // We are a rule with no specific target, it applies to the whole
               // object, let's set the offset to zero
               offset = 0;
            } else {
               // -- No dictionary meta info for this data member, it must no
               // longer exist
               if (fEntries == 0) {
                  // ... unless we creating the branch in which case
                  // we have an internal error.
                  if (pClass->GetListOfRealData()->GetEntries() == 0) {
                     // We are probably missing the ShowMember, let's
                     // just issue an error.
                     Error("InitializeOffsets",
                           "Could not find the real data member '%s' when constructing the branch '%s' [Likely missing ShowMember].",
                           dataName.Data(),GetName());
                  } else if (subInfo && subInfo->GetClassVersion()!=subInfo->GetClass()->GetClassVersion()) {
                     // In the case where we are cloning a TTree that was created with an older version of the layout, we may not
                     // able to find all the members
                     Info("InitializeOffsets",
                           "TTree created with an older schema, some data might not be copied in 'slow-cloning' mode; fast-cloning should have the correct result. '%s' is missing when constructing the branch '%s'. ",
                           dataName.Data(),GetName());
                  } else {
                     // Something really bad happen.
                     Fatal("InitializeOffsets",
                           "Could not find the real data member '%s' when constructing the branch '%s' [Likely an internal error, please report to the developers].",
                           dataName.Data(),GetName());
                  }
               }
               localOffset = TStreamerInfo::kMissing;
            }
         } else {
            // -- We have no data member name, ok for a base class, not good otherwise.
            if (isBaseSubBranch) {
               // I am a direct base class of my parent class, my local offset is enough.
            } else {
               Warning("InitializeOffsets", "Could not find the data member name for branch '%s' with parent branch '%s', assuming offset is zero!", subBranch->GetName(), GetName());
            }
         }

         //
         // Ok, do final calculations for fOffset and fBranchOffset.
         //

         if (isContDataMember) {
            // -- Container data members set fOffset instead of fBranchOffset.
            // The fOffset is what should be added to the start of the entry
            // in the collection (i.e., its current absolute address) to find
            // the beginning of the data member described by the current branch.
            //
            // Compensate for the i/o routines adding our local offset later.
            if (subBranch->fObject == 0 && localOffset == TStreamerInfo::kMissing) {
               subBranch->SetOffset(TStreamerInfo::kMissing);
               // We stil need to set fBranchOffset in the case of a missing
               // element so that SetAddress is (as expected) not called
               // recursively in this case.
               fBranchOffset[subBranchIdx] = TStreamerInfo::kMissing;
            } else {
               if (isBaseSubBranch) {
                  // The value of 'offset' for a base class does not include its
                  // 'localOffset'.
                  subBranch->SetOffset(offset);
               } else {
                  // The value of 'offset' for a regular data member does include its
                  // 'localOffset', we need to remove it explicitly.
                  subBranch->SetOffset(offset - localOffset);
               }
            }
         } else {
            // -- Set fBranchOffset for sub-branch.
            Int_t isSplit = 0 != subBranch->GetListOfBranches()->GetEntriesFast();
            if (subBranch->fObject == 0 && localOffset == TStreamerInfo::kMissing) {
               // The branch is missing
               fBranchOffset[subBranchIdx] = TStreamerInfo::kMissing;

            } else if (isSplit) {
               if (isBaseSubBranch) {
                  // We are split, so we need to add in our local offset
                  // to get our absolute address for our children.
                  fBranchOffset[subBranchIdx] = offset + localOffset;
               } else {
                  // We are split so our offset will never be
                  // used in an i/o, so we do not have to subtract
                  // off our local offset like below.
                  fBranchOffset[subBranchIdx] = offset;
               }
            } else {
               if (isBaseSubBranch) {
                  // We are not split, so our local offset will be
                  // added later by the i/o routines.
                  fBranchOffset[subBranchIdx] = offset;
               } else {
                  // Compensate for the fact that the i/o routines
                  // are going to add my local offset later.
                  fBranchOffset[subBranchIdx] = offset - localOffset;
               }
            }
         }
      }
   }
   else {
      if (fID > -1) {
         // Branch is *not* a top-level branch.
         // Let's check if the target member is still present in memory
         if (GetOffset() == TStreamerInfo::kMissing) {
            fObject = 0;
         }
      }
   }
   fInitOffsets = kTRUE;
}

//______________________________________________________________________________
Bool_t TBranchElement::IsFolder() const
{
   // -- Return kTRUE if more than one leaf, kFALSE otherwise.

   Int_t nbranches = fBranches.GetEntriesFast();
   if (nbranches >= 1) {
      return kTRUE;
   }
   TList* browsables = const_cast<TBranchElement*>(this)->GetBrowsables();
   return browsables && browsables->GetSize();
}

//______________________________________________________________________________
Bool_t TBranchElement::IsMissingCollection() const
{
   // -- Detect a collection written using a zero pointer in old versions of root.
   // In versions of ROOT older than 4.00/03, if a collection (TClonesArray
   // or STL container) was split but the pointer to the collection was zeroed
   // out, nothing was saved.  Hence there is no __easy__ way to detect the
   // case.  In newer versions, a zero is written so that a 'missing' collection
   // appears to be an empty collection.

   Bool_t ismissing = kFALSE;
   TBasket* basket = (TBasket*) fBaskets.UncheckedAt(fReadBasket);
   if (basket && fTree) {
      Long64_t entry = fTree->GetReadEntry();
      Long64_t first  = fBasketEntry[fReadBasket];
      Long64_t last;
      if (fReadBasket == fWriteBasket) {
         last = fEntryNumber - 1;
      } else {
         last = fBasketEntry[fReadBasket+1] - 1;
      }
      Int_t* entryOffset = basket->GetEntryOffset();
      Int_t bufbegin;
      Int_t bufnext;
      if (entryOffset) {
         bufbegin = entryOffset[entry-first];

         if (entry < last) {
            bufnext = entryOffset[entry+1-first];
         } else {
            bufnext = basket->GetLast();
         }
         if (bufnext == bufbegin) {
            ismissing = kTRUE;
         } else {
            // fixed length buffer so this is not the case here.
            if (basket->GetNevBufSize() == 0) {
               ismissing = kTRUE;
            }
         }
      }
   }
   return ismissing;
}

//______________________________________________________________________________
void TBranchElement::Print(Option_t* option) const
{
   // Print branch parameters.

   Int_t nbranches = fBranches.GetEntriesFast();
   if (strncmp(option,"debugAddress",strlen("debugAddress"))==0) {
      if (strlen(option)==strlen("debugAddress")) {
         Printf("%-24s %-16s %2s %4s %-16s %-16s %8s %8s %s\n",
                "Branch Name", "Streamer Class", "ID", "Type", "Class", "Parent", "pOffset", "fOffset", "fObject");
      }
      if (strlen(GetName())>24) Printf("%-24s\n%-24s ", GetName(),"");
      else Printf("%-24s ", GetName());

      TBranchElement *parent = dynamic_cast<TBranchElement*>(GetMother()->GetSubBranch(this));
      Int_t ind = parent ? parent->GetListOfBranches()->IndexOf(this) : -1;
      TVirtualStreamerInfo *info = ((TBranchElement*)this)->GetInfoImp();

      Printf("%-16s %2d %4d %-16s %-16s %8x %8x %s\n",
             info ? info->GetName() : "StreamerInfo unvailable", GetID(), GetType(),
             GetClassName(), GetParentName(),
             (fBranchOffset&&parent && ind>=0) ? parent->fBranchOffset[ind] : 0,
             GetOffset(), GetObject());
      for (Int_t i = 0; i < nbranches; ++i) {
         TBranchElement* subbranch = (TBranchElement*)fBranches.At(i);
         subbranch->Print("debugAddressSub");
      }
      return;
   }
   if (strncmp(option,"debugInfo",strlen("debugInfo"))==0)  {
      Printf("Branch %s uses:",GetName());
      if (fID>=0) {
         GetInfoImp()->GetElement(fID)->ls();
         for(UInt_t i=0; i< fIDs.size(); ++i) {
            GetInfoImp()->GetElement(fIDs[i])->ls();
         }
         Printf("   with read actions:");
         if (fReadActionSequence) fReadActionSequence->Print(option);
         Printf("   with write actions:");
         if (fFillActionSequence) fFillActionSequence->Print(option);
      }
      TString suboption = "debugInfoSub";
      suboption += (option+strlen("debugInfo"));
      for (Int_t i = 0; i < nbranches; ++i) {
         TBranchElement* subbranch = (TBranchElement*)fBranches.At(i);
         subbranch->Print(suboption);
      }
      Printf(" ");
      return;
   }
   if (nbranches) {
      if (fID == -2) {
         if (strcmp(GetName(),GetTitle()) == 0) {
            Printf("*Branch  :%-66s *",GetName());
         } else {
            Printf("*Branch  :%-9s : %-54s *",GetName(),GetTitle());
         }
         Printf("*Entries : %8d : BranchElement (see below)                              *",Int_t(fEntries));
         Printf("*............................................................................*");
      }
      if (fType >= 2) {
         TBranch::Print(option);
      }
      for (Int_t i=0;i<nbranches;i++) {
         TBranch *branch = (TBranch*)fBranches.At(i);
         branch->Print(option);
      }
   } else {
      TBranch::Print(option);
   }
}

//______________________________________________________________________________
void TBranchElement::PrintValue(Int_t lenmax) const
{
   // -- Prints values of leaves.

   ValidateAddress();

   TStreamerInfo *info = GetInfoImp();
   Int_t prID = fID;
   char *object = fObject;
   if (TestBit(kCache)) {
      if (info->GetElements()->At(fID)->TestBit(TStreamerElement::kRepeat)) {
         prID = fID+1;
      } else if (fOnfileObject) {
         object = fOnfileObject->GetObjectAt(0);
      }
   }

   if (fTree->GetMakeClass()) {
      if (!fAddress) {
         return;
      }
      if (fType == 3 || fType == 4) {
         // TClonesArray or STL container top-level branch.
         printf(" %-15s = %d\n", GetName(), fNdata);
         return;
      } else if (fType == 31 || fType == 41) {
         // TClonesArray or STL container sub-branch.
         Int_t n = TMath::Min(10, fNdata);
         Int_t atype = fStreamerType + TVirtualStreamerInfo::kOffsetL;
         if (fStreamerType == TVirtualStreamerInfo::kChar) {
            // TVirtualStreamerInfo::kOffsetL + TVirtualStreamerInfo::kChar is
            // printed as a string and could print weird characters.
            // So we print an unsigned char instead (not perfect, but better).
            atype = TVirtualStreamerInfo::kOffsetL + TVirtualStreamerInfo::kUChar;
         }
         if (atype > 54) {
            // FIXME: More logic required here (like in ReadLeaves)
            printf(" %-15s = %d\n", GetName(), fNdata);
            return;
         }
         if (fStreamerType > 20) {
            atype -= 20;
            TLeafElement* leaf = (TLeafElement*) fLeaves.UncheckedAt(0);
            n = n * leaf->GetLenStatic();
         }
         if (GetInfoImp()) {
            GetInfoImp()->PrintValue(GetName(), fAddress, atype, n, lenmax);
         }
         return;
      } else if (fType <= 2) {
         // Branch in split mode.
         // FIXME: This should probably be < 60 instead.
         if ((fStreamerType > 40) && (fStreamerType < 55)) {
            Int_t atype = fStreamerType - 20;
            TBranchElement* counterElement = (TBranchElement*) fBranchCount;
            Int_t n = (Int_t) counterElement->GetValue(0, 0);
            if (GetInfoImp()) {
               GetInfoImp()->PrintValue(GetName(), fAddress, atype, n, lenmax);
            }
         } else {
            if (GetInfoImp()) {
               GetInfoImp()->PrintValue(GetName(), object, prID, -1, lenmax);
            }
         }
         return;
      }
   } else if (fType == 3) {
      printf(" %-15s = %d\n", GetName(), fNdata);
   } else if (fType == 31) {
      TClonesArray* clones = (TClonesArray*) object;
      if (GetInfoImp()) {
         GetInfoImp()->PrintValueClones(GetName(), clones, prID, fOffset, lenmax);
      }
   } else if (fType == 41) {
      TVirtualCollectionProxy::TPushPop helper(((TBranchElement*) this)->GetCollectionProxy(), object);
      if (GetInfoImp()) {
         GetInfoImp()->PrintValueSTL(GetName(), ((TBranchElement*) this)->GetCollectionProxy(), prID, fOffset, lenmax);
      }
   } else {
      if (GetInfoImp()) {
         GetInfoImp()->PrintValue(GetName(), object, prID, -1, lenmax);
      }
   }
}

//______________________________________________________________________________
void  TBranchElement::ReadLeavesImpl(TBuffer&)
{
   // -- Unconfiguration Read Leave function.

   Fatal("ReadLeaves","The ReadLeaves function has not been configured for %s",GetName());
}

//______________________________________________________________________________
void TBranchElement::ReadLeavesMakeClass(TBuffer& b)
{
   // -- Read leaves into i/o buffers for this branch.
   // For the case where the branch is set in MakeClass mode (decomposed object).

   ValidateAddress();

   if (fType == 3 || fType == 4) {
      // Top level branch of a TClonesArray.
      Int_t *n = (Int_t*) fAddress;
      b >> n[0];
      if ((n[0] < 0) || (n[0] > fMaximum)) {
         if (IsMissingCollection()) {
            n[0] = 0;
            b.SetBufferOffset(b.Length() - sizeof(n));
         } else {
            Error("ReadLeaves", "Incorrect size read for the container in %s\nThe size read is %d when the maximum is %d\nThe size is reset to 0 for this entry (%lld)", GetName(), n[0], fMaximum, GetReadEntry());
            n[0] = 0;
         }
      }
      fNdata = n[0];
      if (fType == 4)   {
         Int_t nbranches = fBranches.GetEntriesFast();
         switch(fSTLtype) {
            case ROOT::kSTLset:
            case ROOT::kSTLmultiset:
            case ROOT::kSTLmap:
            case ROOT::kSTLmultimap:
               for (Int_t i=0; i<nbranches; i++) {
                  TBranch *branch = (TBranch*)fBranches[i];
                  Int_t nb = branch->GetEntry(GetReadEntry(), 1);
                  if (nb < 0) {
                     break;
                  }
               }
               break;
            default:
               break;
         }
      }
      return;
   } else if (fType == 31 || fType == 41) {    // sub branch of a TClonesArray
      fNdata = fBranchCount->GetNdata();
      Int_t atype = fStreamerType;
      // FIXME: This should probably be > 59 instead.
      if (atype > 54) return;
      if (!fAddress) {
         return;
      }
      Int_t n = fNdata;
      if (atype>40) {
         atype -= 40;
         if (!fBranchCount2) return;
         const char *len_where = (char*)fBranchCount2->fAddress;
         if (!len_where) return;
         Int_t len_atype = fBranchCount2->fStreamerType;
         Int_t length;
         Int_t k;
         Char_t isArray;
         for( k=0; k<n; k++) {
            char **where = &(((char**)fAddress)[k]);
            delete [] *where;
            *where = 0;
            switch(len_atype) {
               case  1:  {length = ((Char_t*)   len_where)[k]; break;}
               case  2:  {length = ((Short_t*)  len_where)[k]; break;}
               case  3:  {length = ((Int_t*)    len_where)[k]; break;}
               case  4:  {length = ((Long_t*)   len_where)[k]; break;}
                  //case  5:  {length = ((Float_t*) len_where)[k]; break;}
               case  6:  {length = ((Int_t*)    len_where)[k]; break;}
                  //case  8:  {length = ((Double_t*)len_where)[k]; break;}
               case 11:  {length = ((UChar_t*)  len_where)[k]; break;}
               case 12:  {length = ((UShort_t*) len_where)[k]; break;}
               case 13:  {length = ((UInt_t*)   len_where)[k]; break;}
               case 14:  {length = ((ULong_t*)  len_where)[k]; break;}
               case 15:  {length = ((UInt_t*)   len_where)[k]; break;}
               case 16:  {length = ((Long64_t*) len_where)[k]; break;}
               case 17:  {length = ((ULong64_t*)len_where)[k]; break;}
               case 18:  {length = ((Bool_t*)   len_where)[k]; break;}
               default: continue;
            }
            b >> isArray;
            if (length <= 0)  continue;
            if (isArray == 0) continue;
            switch (atype) {
               case  1:  {*where=new char[sizeof(Char_t)*length]; b.ReadFastArray((Char_t*) *where, length); break;}
               case  2:  {*where=new char[sizeof(Short_t)*length]; b.ReadFastArray((Short_t*) *where, length); break;}
               case  3:  {*where=new char[sizeof(Int_t)*length]; b.ReadFastArray((Int_t*)   *where, length); break;}
               case  4:  {*where=new char[sizeof(Long_t)*length]; b.ReadFastArray((Long_t*)  *where, length); break;}
               case  5:  {*where=new char[sizeof(Float_t)*length]; b.ReadFastArray((Float_t*) *where, length); break;}
               case  6:  {*where=new char[sizeof(Int_t)*length]; b.ReadFastArray((Int_t*)   *where, length); break;}
               case  8:  {*where=new char[sizeof(Double_t)*length]; b.ReadFastArray((Double_t*)*where, length); break;}
               case 11:  {*where=new char[sizeof(UChar_t)*length]; b.ReadFastArray((UChar_t*) *where, length); break;}
               case 12:  {*where=new char[sizeof(UShort_t)*length]; b.ReadFastArray((UShort_t*)*where, length); break;}
               case 13:  {*where=new char[sizeof(UInt_t)*length]; b.ReadFastArray((UInt_t*)  *where, length); break;}
               case 14:  {*where=new char[sizeof(ULong_t)*length]; b.ReadFastArray((ULong_t*) *where, length); break;}
               case 15:  {*where=new char[sizeof(UInt_t)*length]; b.ReadFastArray((UInt_t*)  *where, length); break;}
               case 16:  {*where=new char[sizeof(Long64_t)*length]; b.ReadFastArray((Long64_t*)  *where, length); break;}
               case 17:  {*where=new char[sizeof(ULong64_t)*length]; b.ReadFastArray((ULong64_t*)*where, length); break;}
               case 18:  {*where=new char[sizeof(Bool_t)*length]; b.ReadFastArray((Bool_t*) *where, length); break;}
            }
         }
         return;
      }
      if (atype > 20) {
         atype -= 20;
         TLeafElement *leaf = (TLeafElement*)fLeaves.UncheckedAt(0);
         n *= leaf->GetLenStatic();
      }
      switch (atype) {
         case  1:  {b.ReadFastArray((Char_t*)  fAddress, n); break;}
         case  2:  {b.ReadFastArray((Short_t*) fAddress, n); break;}
         case  3:  {b.ReadFastArray((Int_t*)   fAddress, n); break;}
         case  4:  {b.ReadFastArray((Long_t*)  fAddress, n); break;}
         case  5:  {b.ReadFastArray((Float_t*) fAddress, n); break;}
         case  6:  {b.ReadFastArray((Int_t*)   fAddress, n); break;}
         case  8:  {b.ReadFastArray((Double_t*)fAddress, n); break;}
         case 11:  {b.ReadFastArray((UChar_t*) fAddress, n); break;}
         case 12:  {b.ReadFastArray((UShort_t*)fAddress, n); break;}
         case 13:  {b.ReadFastArray((UInt_t*)  fAddress, n); break;}
         case 14:  {b.ReadFastArray((ULong_t*) fAddress, n); break;}
         case 15:  {b.ReadFastArray((UInt_t*)  fAddress, n); break;}
         case 16:  {b.ReadFastArray((Long64_t*)fAddress, n); break;}
         case 17:  {b.ReadFastArray((ULong64_t*)fAddress, n); break;}
         case 18:  {b.ReadFastArray((Bool_t*)  fAddress, n); break;}
         case  9:  {
            TVirtualStreamerInfo* si = GetInfoImp();
            TStreamerElement* se = (TStreamerElement*) si->GetElement(fID);
            Double_t *xx = (Double_t*) fAddress;
            for (Int_t ii=0;ii<n;ii++) {
               b.ReadDouble32(&(xx[ii]),se);
            }
            break;
         }
         case  19:  {
            TVirtualStreamerInfo* si = GetInfoImp();
            TStreamerElement* se = (TStreamerElement*) si->GetElement(fID);
            Float_t *xx = (Float_t*) fAddress;
            for (Int_t ii=0;ii<n;ii++) {
               b.ReadFloat16(&(xx[ii]),se);
            }
            break;
         }
      }
      return;
   } else if (fType <= 2) {     // branch in split mode
                                // FIXME: This should probably be < 60 instead.
      if (fStreamerType > 40 && fStreamerType < 55) {
         Int_t atype = fStreamerType - 40;
         Int_t n;
         if (fBranchCount==0) {
            // Missing fBranchCount.  let's attempts to recover.

            TString countname( GetName() );
            Ssiz_t dot = countname.Last('.');
            if (dot>=0) {
               countname.Remove(dot+1);
            } else {
               countname = "";
            }
            TString counter( GetTitle() );
            Ssiz_t loc = counter.Last('[');
            if (loc>=0) {
               counter.Remove(0,loc+1);
            }
            loc = counter.Last(']');
            if (loc>=0) {
               counter.Remove(loc);
            }
            countname += counter;
            SetBranchCount((TBranchElement *)fTree->GetBranch(countname));
         }
         if (fBranchCount) {
            n = (Int_t)fBranchCount->GetValue(0,0);
         } else {
            Warning("ReadLeaves","Missing fBranchCount for %s.  Data will not be read correctly by the MakeClass mode.",GetName());
            n = 0;
         }
         fNdata = n;
         Char_t isArray;
         b >> isArray;
         switch (atype) {
            case  1:  {b.ReadFastArray((Char_t*)  fAddress, n); break;}
            case  2:  {b.ReadFastArray((Short_t*) fAddress, n); break;}
            case  3:  {b.ReadFastArray((Int_t*)   fAddress, n); break;}
            case  4:  {b.ReadFastArray((Long_t*)  fAddress, n); break;}
            case  5:  {b.ReadFastArray((Float_t*) fAddress, n); break;}
            case  6:  {b.ReadFastArray((Int_t*)   fAddress, n); break;}
            case  8:  {b.ReadFastArray((Double_t*)fAddress, n); break;}
            case 11:  {b.ReadFastArray((UChar_t*) fAddress, n); break;}
            case 12:  {b.ReadFastArray((UShort_t*)fAddress, n); break;}
            case 13:  {b.ReadFastArray((UInt_t*)  fAddress, n); break;}
            case 14:  {b.ReadFastArray((ULong_t*) fAddress, n); break;}
            case 15:  {b.ReadFastArray((UInt_t*)  fAddress, n); break;}
            case 16:  {b.ReadFastArray((Long64_t*) fAddress, n); break;}
            case 17:  {b.ReadFastArray((ULong64_t*)fAddress, n); break;}
            case 18:  {b.ReadFastArray((Bool_t*)   fAddress, n); break;}
            case  9:  {
               TVirtualStreamerInfo* si = GetInfoImp();
               TStreamerElement* se = (TStreamerElement*) si->GetElement(fID);
               Double_t *xx = (Double_t*) fAddress;
               for (Int_t ii=0;ii<n;ii++) {
                  b.ReadDouble32(&(xx[ii]),se);
               }
               break;
            }
            case  19:  {
               TVirtualStreamerInfo* si = GetInfoImp();
               TStreamerElement* se = (TStreamerElement*) si->GetElement(fID);
               Float_t *xx = (Float_t*) fAddress;
               for (Int_t ii=0;ii<n;ii++) {
                  b.ReadFloat16(&(xx[ii]),se);
               }
               break;
            }
         }
      } else {
         fNdata = 1;
         if (fAddress) {
            if (fType<0) {
               // Non TObject, Non collection classes with a custom streamer.

               // if (fObject)
               fBranchClass->Streamer(fObject,b);
            } else {
               TStreamerInfo *info = GetInfoImp();
               if (!info) {
                  return;
               }
               // Since info is not null, fReadActionSequence is not null either.
               b.ApplySequence(*fReadActionSequence, fObject);
            }
            if (fStreamerType == TVirtualStreamerInfo::kCounter) {
               fNdata = (Int_t) GetValue(0, 0);
            }
         } else {
            fNdata = 0;
         }
      }
      return;
   }
}

//______________________________________________________________________________
void TBranchElement::ReadLeavesCollection(TBuffer& b)
{
   // -- Read leaves into i/o buffers for this branch.
   // Case of a collection (fType == 4).

   ValidateAddress();
   if (fObject == 0)
   {
      // We have nowhere to copy the data (probably because the data member was
      // 'dropped' from the current schema) so let's no copy it in a random place.
      return;
   }

   // STL container master branch (has only the number of elements).
   Int_t n;
   b >> n;
   if ((n < 0) || (n > fMaximum)) {
      if (IsMissingCollection()) {
         n = 0;
         b.SetBufferOffset(b.Length()-sizeof(n));
      } else {
         Error("ReadLeaves", "Incorrect size read for the container in %s\n\tThe size read is %d while the maximum is %d\n\tThe size is reset to 0 for this entry (%lld)", GetName(), n, fMaximum, GetReadEntry());
         n = 0;
      }
   }
   fNdata = n;

   R__PushCache onfileObject(((TBufferFile&)b),fOnfileObject,n);

   // Note: Proxy-helper needs to "embrace" the entire
   //       streaming of this STL container if the container
   //       is a set/multiset/map/multimap (what we do not
   //       know here).
   //       For vector/list/deque Allocate == Resize
   //                         and Commit   == noop.
   // TODO: Exception safety a la TPushPop
   TVirtualCollectionProxy* proxy = GetCollectionProxy();
   TVirtualCollectionProxy::TPushPop helper(proxy, fObject);
   void* alternate = proxy->Allocate(fNdata, true);
   if(fSTLtype != ROOT::kSTLvector && proxy->HasPointers() && fSplitLevel > TTree::kSplitCollectionOfPointers ) {
      fPtrIterators->CreateIterators(alternate, proxy);
   } else {
      fIterators->CreateIterators(alternate, proxy);
   }

   Int_t nbranches = fBranches.GetEntriesFast();
   switch (fSTLtype) {
      case ROOT::kSTLset:
      case ROOT::kSTLunorderedset:
      case ROOT::kSTLunorderedmultiset:
      case ROOT::kSTLmultiset:
      case ROOT::kSTLmap:
      case ROOT::kSTLmultimap:
      case ROOT::kSTLunorderedmap:
      case ROOT::kSTLunorderedmultimap:
         for (Int_t i = 0; i < nbranches; ++i) {
            TBranch *branch = (TBranch*) fBranches[i];
            Int_t nb = branch->GetEntry(GetReadEntry(), 1);
            if (nb < 0) {
               // Give up on i/o failure.
               // FIXME: We need an error message here.
               break;
            }
         }
         break;
      default:
         break;
   }
   //------------------------------------------------------------------------
   // We have split this stuff, so we need to create the the pointers
   //-----------------------------------------------------------------------
   if( proxy->HasPointers() && fSplitLevel > TTree::kSplitCollectionOfPointers )
   {
      TClass *elClass = proxy->GetValueClass();

      //--------------------------------------------------------------------
      // The allocation is done in this strange way because ReadLeaves
      // is being called many times by TTreeFormula!!!
      //--------------------------------------------------------------------
      Int_t i = 0;
      // coverity[returned_null] the fNdata is check enough to prevent the use of null value of At(0)
      if( !fNdata || *(void**)proxy->At( 0 ) != 0 )
         i = fNdata;

      for( ; i < fNdata; ++i )
      {
         void **el = (void**)proxy->At( i );
         // coverity[dereference] since this is a member streaming action by definition the collection contains objects and elClass is not null.
         *el = elClass->New();
      }
   }

   proxy->Commit(alternate);
}

//______________________________________________________________________________
void TBranchElement::ReadLeavesCollectionSplitPtrMember(TBuffer& b)
{
   // -- Read leaves into i/o buffers for this branch.
   // Case of a data member within a collection (fType == 41).

   ValidateAddress();
   if (fObject == 0)
   {
      // We have nowhere to copy the data (probably because the data member was
      // 'dropped' from the current schema) so let's no copy it in a random place.
      return;
   }

   // STL container sub-branch (contains the elements).
   fNdata = fBranchCount->GetNdata();
   if (!fNdata) {
      return;
   }

   R__PushCache onfileObject(((TBufferFile&)b),fOnfileObject,fNdata);

   TStreamerInfo *info = GetInfoImp();
   if (info == 0) return;

   TVirtualCollectionProxy *proxy = GetCollectionProxy();
   TVirtualCollectionProxy::TPushPop helper(proxy, fObject);

   // R__ASSERT(0);
   TVirtualCollectionPtrIterators *iter = fBranchCount->fPtrIterators;
   b.ApplySequence(*fReadActionSequence,iter->fBegin,iter->fEnd);

   //   char **arr = (char **)proxy->At(0);
   //   char **end = arr + proxy->Size();
   //   fReadActionSequence->ReadBufferVecPtr(b,arr,end);

   //   info->ReadBufferSTLPtrs(b, proxy, fNdata, fID, fOffset);
   //   for(UInt_t ii=0; ii < fIDs.size(); ++ii) {
   //      info->ReadBufferSTLPtrs(b, proxy, fNdata, fIDs[ii], fOffset);
   //   }
}

//______________________________________________________________________________
void TBranchElement::ReadLeavesCollectionSplitVectorPtrMember(TBuffer& b)
{
   // -- Read leaves into i/o buffers for this branch.
   // Case of a data member within a collection (fType == 41).

   ValidateAddress();
   if (fObject == 0)
   {
      // We have nowhere to copy the data (probably because the data member was
      // 'dropped' from the current schema) so let's no copy it in a random place.
      return;
   }

   // STL container sub-branch (contains the elements).
   fNdata = fBranchCount->GetNdata();
   if (!fNdata) {
      return;
   }
   R__PushCache onfileObject(((TBufferFile&)b),fOnfileObject,fNdata);

   TStreamerInfo *info = GetInfoImp();
   if (info == 0) return;

   TVirtualCollectionProxy *proxy = GetCollectionProxy();
   TVirtualCollectionProxy::TPushPop helper(proxy, fObject);

   TVirtualCollectionIterators *iter = fBranchCount->fIterators;
   b.ApplySequenceVecPtr(*fReadActionSequence,iter->fBegin,iter->fEnd);
}

//______________________________________________________________________________
void TBranchElement::ReadLeavesCollectionMember(TBuffer& b)
{
   // -- Read leaves into i/o buffers for this branch.
   // Case of a data member within a collection (fType == 41).

   ValidateAddress();
   if (fObject == 0)
   {
      // We have nowhere to copy the data (probably because the data member was
      // 'dropped' from the current schema) so let's no copy it in a random place.
      return;
   }

   // STL container sub-branch (contains the elements).
   fNdata = fBranchCount->GetNdata();
   if (!fNdata) {
      return;
   }
   R__PushCache onfileObject(((TBufferFile&)b),fOnfileObject,fNdata);

   TStreamerInfo *info = GetInfoImp();
   if (info == 0) return;
   // Since info is not null, fReadActionSequence is not null either.

   // Still calling PushPop for the legacy entries.
   TVirtualCollectionProxy *proxy = GetCollectionProxy();
   TVirtualCollectionProxy::TPushPop helper(proxy, fObject);

   TVirtualCollectionIterators *iter = fBranchCount->fIterators;
   b.ApplySequence(*fReadActionSequence,iter->fBegin,iter->fEnd);
}

//______________________________________________________________________________
void TBranchElement::ReadLeavesClones(TBuffer& b)
{
   // -- Read leaves into i/o buffers for this branch.
   // Case of a TClonesArray (fType == 3).

   ValidateAddress();
   if (fObject == 0)
   {
      // We have nowhere to copy the data (probably because the data member was
      // 'dropped' from the current schema) so let's no copy it in a random place.
      return;
   }

   // TClonesArray master branch (has only the number of elements).
   Int_t n;
   b >> n;
   if ((n < 0) || (n > fMaximum)) {
      if (IsMissingCollection()) {
         n = 0;
         b.SetBufferOffset(b.Length()-sizeof(n));
      } else {
         Error("ReadLeaves", "Incorrect size read for the container in %s\n\tThe size read is %d while the maximum is %d\n\tThe size is reset to 0 for this entry (%lld)", GetName(), n, fMaximum, GetReadEntry());
         n = 0;
      }
   }
   fNdata = n;
   TClonesArray* clones = (TClonesArray*) fObject;
   if (clones->IsZombie()) {
      return;
   }
   // The salient part of Clear is now 'duplicated in ExpandCreateFast (i.e. the
   // setting to zero of the unused slots), so we no longer need to call Clear explicitly
   //    clones->Clear();
   clones->ExpandCreateFast(fNdata);
}

//______________________________________________________________________________
void TBranchElement::ReadLeavesClonesMember(TBuffer& b)
{
   // -- Read leaves into i/o buffers for this branch.
   // Case of a data member within a TClonesArray (fType == 31).

   // No need to validate the address here, if we are a member of a split ClonesArray,
   // fID is positive
   //   ValidateAddress();

   if (fObject == 0)
   {
      // We have nowhere to copy the data (probably because the data member was
      // 'dropped' from the current schema) so let's no copy it in a random place.
      return;
   }

   // TClonesArray sub-branch (contains the elements).
   fNdata = fBranchCount->GetNdata();
   TClonesArray* clones = (TClonesArray*) fObject;
   if (clones->IsZombie()) {
      return;
   }
   TStreamerInfo *info = GetInfoImp();
   if (info==0) return;
   // Since info is not null, fReadActionSequence is not null either.

   // Note, we could (possibly) save some more, by configuring the action
   // based on the value of fOnfileObject rather than pushing in on a stack.
   R__PushCache onfileObject(((TBufferFile&)b),fOnfileObject,fNdata);

   char **arr = (char **)clones->GetObjectRef();
   char **end = arr + fNdata;
   b.ApplySequenceVecPtr(*fReadActionSequence,arr,end);
}

//______________________________________________________________________________
void TBranchElement::ReadLeavesMember(TBuffer& b)
{
   // -- Read leaves into i/o buffers for this branch.
   // For split-class branch, base class branch, data member branch, or top-level branch.
   // which do not have a branch count and are not a counter.

   R__ASSERT(fBranchCount==0);
   R__ASSERT(fStreamerType != TVirtualStreamerInfo::kCounter);

   ValidateAddress();
   if (fObject == 0)
   {
      // We have nowhere to copy the data (probably because the data member was
      // 'dropped' from the current schema) so let's no copy it in a random place.
      return;
   }

   R__PushCache onfileObject(((TBufferFile&)b),fOnfileObject,1);
   // If not a TClonesArray or STL container master branch
   // or sub-branch and branch inherits from tobject,
   // then register with the buffer so that pointers are
   // handled properly.
   if (TestBit(kBranchObject)) {
      b.MapObject((TObject*) fObject);
   } else if (TestBit(kBranchAny)) {
      b.MapObject(fObject, fBranchClass);
   }

   fNdata = 1;
   TStreamerInfo *info = GetInfoImp();
   if (!info) {
      return;
   }
   // Since info is not null, fReadActionSequence is not null either.
   b.ApplySequence(*fReadActionSequence, fObject);
}

//______________________________________________________________________________
void TBranchElement::ReadLeavesMemberBranchCount(TBuffer& b)
{
   // -- Read leaves into i/o buffers for this branch.
   // For split-class branch, base class branch, data member branch, or top-level branch.
   // which do have a branch count and are not a counter.

   R__ASSERT(fStreamerType != TVirtualStreamerInfo::kCounter);

   ValidateAddress();
   if (fObject == 0)
   {
      // We have nowhere to copy the data (probably because the data member was
      // 'dropped' from the current schema) so let's no copy it in a random place.
      return;
   }

   // If not a TClonesArray or STL container master branch
   // or sub-branch and branch inherits from tobject,
   // then register with the buffer so that pointers are
   // handled properly.
   if (TestBit(kBranchObject)) {
      b.MapObject((TObject*) fObject);
   } else if (TestBit(kBranchAny)) {
      b.MapObject(fObject, fBranchClass);
   }

   fNdata = (Int_t) fBranchCount->GetValue(0, 0);
   TStreamerInfo *info = GetInfoImp();
   if (!info) {
      return;
   }
   R__PushCache onfileObject(((TBufferFile&)b),fOnfileObject,1); // Here we have a single object that contains a variable size C-style array.
                                                                 // Since info is not null, fReadActionSequence is not null either.
   b.ApplySequence(*fReadActionSequence, fObject);
}

//______________________________________________________________________________
void TBranchElement::ReadLeavesMemberCounter(TBuffer& b)
{
   // -- Read leaves into i/o buffers for this branch.
   // For split-class branch, base class branch, data member branch, or top-level branch.
   // which do not have a branch count and are a counter.

   ValidateAddress();
   if (fObject == 0)
   {
      // We have nowhere to copy the data (probably because the data member was
      // 'dropped' from the current schema) so let's no copy it in a random place.
      return;
   }

   // If not a TClonesArray or STL container master branch
   // or sub-branch and branch inherits from tobject,
   // then register with the buffer so that pointers are
   // handled properly.
   if (TestBit(kBranchObject)) {
      b.MapObject((TObject*) fObject);
   } else if (TestBit(kBranchAny)) {
      b.MapObject(fObject, fBranchClass);
   }

   TStreamerInfo *info = GetInfoImp();
   if (!info) {
      return;
   }

   R__PushCache onfileObject(((TBufferFile&)b),fOnfileObject,1);

   // Since info is not null, fReadActionSequence is not null either.
   b.ApplySequence(*fReadActionSequence, fObject);
   fNdata = (Int_t) GetValue(0, 0);
}

//______________________________________________________________________________
void TBranchElement::ReadLeavesCustomStreamer(TBuffer& b)
{
   // -- Read leaves into i/o buffers for this branch.
   // Non TObject, Non collection classes with a custom streamer.

   ValidateAddress();
   if (fObject == 0)
   {
      // We have nowhere to copy the data (probably because the data member was
      // 'dropped' from the current schema) so let's no copy it in a random place.
      return;
   }

   R__PushCache onfileObject(((TBufferFile&)b),fOnfileObject,1);
   fBranchClass->Streamer(fObject,b);
}

//______________________________________________________________________________
void  TBranchElement::FillLeavesImpl(TBuffer&)
{
   // -- Unconfiguration Fill Leave function.

   Fatal("FillLeaves","The FillLeaves function has not been configured for %s",GetName());
}

//______________________________________________________________________________
void TBranchElement::ReleaseObject()
{
   // -- Delete any object we may have allocated on a previous call to SetAddress.

   if (fObject && TestBit(kDeleteObject)) {
      if (IsAutoDelete() && fAddress != (char*)&fObject) {
         *((char**) fAddress) = 0;
      }
      ResetBit(kDeleteObject);
      if (fType == 3) {
         // -- We are a TClonesArray master branch.
         TClonesArray::Class()->Destructor(fObject);
         fObject = 0;
         if ((fStreamerType == TVirtualStreamerInfo::kObjectp) ||
             (fStreamerType == TVirtualStreamerInfo::kObjectP)) {
            // -- We are a pointer to a TClonesArray.
            // We must zero the pointer in the object.
            *((char**) fAddress) = 0;
         }
      } else if (fType == 4) {
         // -- We are an STL container master branch.
         TVirtualCollectionProxy* proxy = GetCollectionProxy();

         if (!proxy) {
            Warning("ReleaseObject", "Cannot delete allocated STL container because I do not have a proxy!  branch: %s", GetName());
            fObject = 0;
         } else {
            Bool_t needDelete = proxy->GetProperties()&TVirtualCollectionProxy::kNeedDelete;
            if (needDelete && fID >= 0) {
               TVirtualStreamerInfo* si = GetInfoImp();
               TStreamerElement* se = (TStreamerElement*) si->GetElement(fID);
               needDelete = !se->TestBit(TStreamerElement::kDoNotDelete);
            }
            if (needDelete) {
               TVirtualCollectionProxy::TPushPop helper(proxy,fObject);
               proxy->Clear("force");
            }
            proxy->Destructor(fObject);
            fObject = 0;
         }
         if (fStreamerType == TVirtualStreamerInfo::kSTLp) {
            // -- We are a pointer to an STL container.
            // We must zero the pointer in the object.
            *((char**) fAddress) = 0;
         }
      } else {
         // We are *not* a TClonesArray master branch and we are *not* an STL container master branch.
         TClass* cl = fBranchClass.GetClass();
         if (!cl) {
            Warning("ReleaseObject", "Cannot delete allocated object because I cannot instantiate a TClass object for its class!  branch: '%s' class: '%s'", GetName(), fBranchClass.GetClassName());
            fObject = 0;
         } else {
            TVirtualCollectionProxy* proxy = cl->GetCollectionProxy();

            if (proxy) {
               if (fID >= 0) {
                  TVirtualStreamerInfo* si = GetInfoImp();
                  TStreamerElement* se = si->GetElement(fID);
                  if (!se->TestBit(TStreamerElement::kDoNotDelete) && proxy->GetProperties()&TVirtualCollectionProxy::kNeedDelete) {
                     TVirtualCollectionProxy::TPushPop helper(proxy,fObject);
                     proxy->Clear("force");
                  }
               } else if (proxy->GetProperties()&TVirtualCollectionProxy::kNeedDelete) {
                  TVirtualCollectionProxy::TPushPop helper(proxy,fObject);
                  proxy->Clear("force");
               }

            }
            cl->Destructor(fObject);
            fObject = 0;
         }
      }
   }
}

//______________________________________________________________________________
void TBranchElement::Reset(Option_t* option)
{
   // Reset a Branch.
   //
   // Existing i/o buffers are deleted.
   // Entries, max and min are reset.
   //

   Int_t nbranches = fBranches.GetEntriesFast();
   for (Int_t i = 0; i < nbranches; ++i) {
      TBranch* branch = (TBranch*) fBranches[i];
      branch->Reset(option);
   }
   fBranchID = -1;
   TBranch::Reset(option);
}

//______________________________________________________________________________
void TBranchElement::ResetAfterMerge(TFileMergeInfo *info)
{
   // Reset a Branch after a Merge operation (drop data but keep customizations)
   //

   Int_t nbranches = fBranches.GetEntriesFast();
   for (Int_t i = 0; i < nbranches; ++i) {
      TBranch* branch = (TBranch*) fBranches[i];
      branch->ResetAfterMerge(info);
   }
   TBranch::ResetAfterMerge(info);
}

//______________________________________________________________________________
void TBranchElement::ResetAddress()
{
   // Set branch address to zero and free all allocated memory.

   for (Int_t i = 0; i < fNleaves; ++i) {
      TLeaf* leaf = (TLeaf*) fLeaves.UncheckedAt(i);
      //if (leaf) leaf->SetAddress(0);
      leaf->SetAddress(0);
   }

   // Note: We *must* do the sub-branches first, otherwise
   //       we may delete the object containing the sub-branches
   //       before giving them a chance to cleanup.
   Int_t nbranches = fBranches.GetEntriesFast();
   for (Int_t i = 0; i < nbranches; ++i)  {
      TBranch* br = (TBranch*) fBranches[i];
      if (br) br->ResetAddress();
   }

   //
   // SetAddress may have allocated an object.
   //

   ReleaseObject();

   ResetBit(kAddressSet);
   fAddress = 0;
   fObject = 0;
}

//______________________________________________________________________________
void TBranchElement::ResetDeleteObject()
{
   // -- Release ownership of any allocated objects.
   //
   // Note: This interface was added so that clone trees could
   //       be told they do not own the allocated objects.

   ResetBit(kDeleteObject);
   Int_t nb = fBranches.GetEntriesFast();
   for (Int_t i = 0; i < nb; ++i)  {
      TBranch* br = (TBranch*) fBranches[i];
      if (br->InheritsFrom(TBranchElement::Class())) {
         ((TBranchElement*) br)->ResetDeleteObject();
      }
   }
}

//______________________________________________________________________________
void TBranchElement::SetAddress(void* addr)
{
   // -- Point this branch at an object.
   //
   // For a sub-branch, addr is a pointer to the branch object.
   //
   // For a top-level branch the meaning of addr is as follows:
   //
   // If addr is zero, then we allocate a branch object
   // internally and the branch is the owner of the allocated
   // object, not the caller.  However the caller may obtain
   // a pointer to the branch object with GetObject().
   //
   // Example:
   //
   //    branch->SetAddress(0);
   //    Event* event = branch->GetObject();
   //    ... Do some work.
   //
   // If addr is not zero, but the pointer addr points at is
   // zero, then we allocate a branch object and set the passed
   // pointer to point at the allocated object.  The caller
   // owns the allocated object and is responsible for deleting
   // it when it is no longer needed.
   //
   // Example:
   //
   //    Event* event = 0;
   //    branch->SetAddress(&event);
   //    ... Do some work.
   //    delete event;
   //    event = 0;
   //
   // If addr is not zero and the pointer addr points at is
   // also not zero, then the caller has allocated a branch
   // object and is asking us to use it.  The caller owns it
   // and must delete it when it is no longer needed.
   //
   // Example:
   //
   //    Event* event = new Event();
   //    branch->SetAddress(&event);
   //    ... Do some work.
   //    delete event;
   //    event = 0;
   //
   // These rules affect users of TTree::Branch(),
   // TTree::SetBranchAddress(), and TChain::SetBranchAddress()
   // as well because those routines call this one.
   //
   // An example of a tree with branches with objects allocated
   // and owned by us:
   //
   //    TFile* f1 = new TFile("myfile_original.root");
   //    TTree* t1 = (TTree*) f->Get("MyTree");
   //    TFile* f2 = new TFile("myfile_copy.root", "recreate");
   //    TTree* t2 = t1->Clone(0);
   //    for (Int_t i = 0; i < 10; ++i) {
   //       t1->GetEntry(i);
   //       t2->Fill();
   //    }
   //    t2->Write()
   //    delete f2;
   //    f2 = 0;
   //    delete f1;
   //    f1 = 0;
   //
   // An example of a branch with an object allocated by us,
   // but owned by the caller:
   //
   //    TFile* f = new TFile("myfile.root", "recreate");
   //    TTree* t = new TTree("t", "A test tree.")
   //    Event* event = 0;
   //    TBranchElement* br = t->Branch("event.", &event);
   //    for (Int_t i = 0; i < 10; ++i) {
   //       ... Fill event with meaningful data in some way.
   //       t->Fill();
   //    }
   //    t->Write();
   //    delete event;
   //    event = 0;
   //    delete f;
   //    f = 0;
   //
   // Notice that the only difference between this example
   // and the following example is that the event pointer
   // is zero when the branch is created.
   //
   // An example of a branch with an object allocated and
   // owned by the caller:
   //
   //    TFile* f = new TFile("myfile.root", "recreate");
   //    TTree* t = new TTree("t", "A test tree.")
   //    Event* event = new Event();
   //    TBranchElement* br = t->Branch("event.", &event);
   //    for (Int_t i = 0; i < 10; ++i) {
   //       ... Fill event with meaningful data in some way.
   //       t->Fill();
   //    }
   //    t->Write();
   //    delete event;
   //    event = 0;
   //    delete f;
   //    f = 0;
   //
   // If AutoDelete is on (see TBranch::SetAutoDelete),
   // the top level objet will be deleted and recreate
   // each time an entry is read, whether or not the
   // TTree owns the object.
   //

   //
   //  Don't bother if we are disabled.
   //

   if (TestBit(kDoNotProcess)) {
      return;
   }

   //
   //  FIXME: When would this happen?
   //

   if (fType < -1) {
      return;
   }

   //
   //  Special case when called from code generated by TTree::MakeClass.
   //

   if (Long_t(addr) == -1) {
      // FIXME: Do we have to release an object here?
      // ReleaseObject();
      fAddress = (char*) -1;
      fObject = (char*) -1;
      ResetBit(kDeleteObject);
      return;
   }

   //
   //  Reset last read entry number, we have a new user object now.
   //

   fReadEntry = -1;

   //
   // Make sure our branch class is instantiated.
   //
   TClass* clOfBranch = fBranchClass.GetClass();
   if( fTargetClass.GetClassName()[0] ) {
      clOfBranch = fTargetClass;
   }

   //
   // Try to build the streamer info.
   //

   TStreamerInfo *info = GetInfoImp();

   // FIXME: Warn about failure to get the streamer info here?

   //
   // We may have allocated an object last time we were called.
   //

   if (fObject && TestBit(kDeleteObject)){
      ReleaseObject();
   }

   //
   //  Remember the pointer to the pointer to our object.
   //

   fAddress = (char*) addr;
   if (fAddress != (char*)(&fObject)) {
      fObject = 0;
   }
   ResetBit(kDeleteObject);

   //
   //  Do special stuff if we got called from a MakeClass class.
   //  Allow sub-branches to have independently set addresses.
   //

   if (fTree->GetMakeClass()) {
      if (fID > -1) {
         // We are *not* a top-level branch.
         if (!info) {
            // No streamer info, give up.
            // FIXME: We should have an error message here.
            fObject = fAddress;
         } else {
            // Compensate for the fact that the i/o routines
            // will add the streamer offset to the address.
            fObject = fAddress - info->TStreamerInfo::GetElementOffset(fID);
         }
         return;
      }
   }

   //
   //  Check whether the container type is still the same
   //  to support schema evolution; what is written on the file
   //  may no longer match the class code which is loaded.
   //

   if (fType == 3) {
      // split TClonesArray, counter/master branch.
      TClass* clm = fClonesClass;
      if (clm) {
         // In case clm derives from an abstract class.
         clm->BuildRealData();
         clm->GetStreamerInfo();
      }
      TClass* newType = GetCurrentClass();
      if (newType && (newType != TClonesArray::Class())) {
         // The data type of the container has changed.
         //
         // Let's check if it is a compatible type:
         Bool_t matched = kFALSE;
         if (newType->GetCollectionProxy()) {
            TClass *content = newType->GetCollectionProxy()->GetValueClass();
            if (clm == content) {
               matched = kTRUE;
            } else {
               Warning("SetAddress", "The type of %s was changed from TClonesArray to %s but the content do not match (was %s)!", GetName(), newType->GetName(), GetClonesName());
            }
         } else {
            Warning("SetAddress", "The type of the %s was changed from TClonesArray to %s but we do not have a TVirtualCollectionProxy for that container type!", GetName(), newType->GetName());
         }
         if (matched) {
            // Change from 3/31 to 4/41
            SetType(4);
            // Set the proxy.
            fSTLtype = newType->GetCollectionType();
            fCollProxy = newType->GetCollectionProxy()->Generate();

            SwitchContainer(GetListOfBranches());
            SetReadLeavesPtr();
            SetFillLeavesPtr();

            if(fSTLtype != ROOT::kSTLvector && fCollProxy->HasPointers() && fSplitLevel > TTree::kSplitCollectionOfPointers ) {
               fPtrIterators = new TVirtualCollectionPtrIterators(fCollProxy);
            } else if (fCollProxy->GetProperties() & TVirtualCollectionProxy::kIsAssociative) {
               fWriteIterators = new TVirtualCollectionIterators(fCollProxy,kFALSE);
               fIterators = new TVirtualCollectionIterators(fCollProxy);
            } else {
               fIterators = new TVirtualCollectionIterators(fCollProxy);
            }
         } else {
            // FIXME: Must maintain fObject here as well.
            fAddress = 0;
         }
      }
   } else if (fType == 4) {
      // split STL container, counter/master branch.
      TClass* newType = GetCurrentClass();
      if (newType && (newType != GetCollectionProxy()->GetCollectionClass())) {
         // Let's check if it is a compatible type:
         TVirtualCollectionProxy* newProxy = newType->GetCollectionProxy();
         TVirtualCollectionProxy* oldProxy = GetCollectionProxy();
         if (newProxy && (oldProxy->GetValueClass() == newProxy->GetValueClass()) && ((!oldProxy->GetValueClass() && (oldProxy->GetType() == newProxy->GetType())) || (oldProxy->GetValueClass() && (oldProxy->HasPointers() == newProxy->HasPointers())))) {
            delete fCollProxy;
            Int_t nbranches = GetListOfBranches()->GetEntries();
            fCollProxy = newType->GetCollectionProxy()->Generate();
            fSTLtype = fCollProxy->GetCollectionType();
            for (Int_t i = 0; i < nbranches; ++i) {
               TBranchElement* br = (TBranchElement*) GetListOfBranches()->UncheckedAt(i);
               br->fCollProxy = 0;
               if (br->fReadActionSequence) {
                  br->SetReadActionSequence();
               }
               if (br->fFillActionSequence) {
                  br->SetFillActionSequence();
               }
            }
            SetReadActionSequence();
            SetFillActionSequence();
            SetReadLeavesPtr();
            SetFillLeavesPtr();
            delete fIterators;
            delete fPtrIterators;
            if(fSTLtype != ROOT::kSTLvector && fCollProxy->HasPointers() && fSplitLevel > TTree::kSplitCollectionOfPointers ) {
               fPtrIterators = new TVirtualCollectionPtrIterators(fCollProxy);
            } else if (fCollProxy->GetProperties() & TVirtualCollectionProxy::kIsAssociative) {
               fWriteIterators = new TVirtualCollectionIterators(fCollProxy,kFALSE);
               fIterators = new TVirtualCollectionIterators(fCollProxy);
            } else {
               fIterators = new TVirtualCollectionIterators(fCollProxy);
            }
         }
         else if (newProxy && (oldProxy->HasPointers() == newProxy->HasPointers()) && (oldProxy->GetValueClass()!=0) && (newProxy->GetValueClass()!=0)) {
            // Let see if there is a rule to convert the content of the collection into each other.
            if (newType->GetSchemaRules()->HasRuleWithSourceClass( oldProxy->GetCollectionClass()->GetName())) {
               TClass *oldValueClass = oldProxy->GetValueClass();
               delete fCollProxy;
               Int_t nbranches = GetListOfBranches()->GetEntries();
               fCollProxy = newType->GetCollectionProxy()->Generate();
               fSTLtype = fCollProxy->GetCollectionType();
               for (Int_t i = 0; i < nbranches; ++i) {
                  TBranchElement* br = (TBranchElement*) GetListOfBranches()->UncheckedAt(i);
                  br->fCollProxy = 0;
                  if (br->fBranchClass == oldValueClass) {
                     br->SetTargetClass(fCollProxy->GetValueClass()->GetName());
                  }
                  if (br->fReadActionSequence) {
                     br->SetReadActionSequence();
                  }
                  if (br->fFillActionSequence) {
                     br->SetFillActionSequence();
                  }
               }
               SetReadActionSequence();
               SetFillActionSequence();
               SetReadLeavesPtr();
               SetFillLeavesPtr();
               delete fIterators;
               delete fPtrIterators;
               if(fSTLtype != ROOT::kSTLvector && fCollProxy->HasPointers() && fSplitLevel > TTree::kSplitCollectionOfPointers ) {
                  fPtrIterators = new TVirtualCollectionPtrIterators(fCollProxy);
               } else if (fCollProxy->GetProperties() & TVirtualCollectionProxy::kIsAssociative) {
                  fWriteIterators = new TVirtualCollectionIterators(fCollProxy,kFALSE);
                  fIterators = new TVirtualCollectionIterators(fCollProxy);
               } else {
                  fIterators = new TVirtualCollectionIterators(fCollProxy);
               }
            } else {
               Error("SetAddress","For %s, we can not convert %s into %s\n",
                     GetName(),oldProxy->GetCollectionClass()->GetName(),newType->GetName());
               fAddress = 0;
               fObject = 0;
               return;
            }
         }
         else if ((newType == TClonesArray::Class()) && (oldProxy->GetValueClass() && !oldProxy->HasPointers() && oldProxy->GetValueClass()->IsTObject()))
         {
            // The new collection and the old collection are not compatible,
            // we cannot use the new collection to read the data.
            // Actually we could check if the new collection is a
            // compatible ROOT collection.

            // We cannot insure that the TClonesArray is set for the
            // proper class (oldProxy->GetValueClass()), so we assume that
            // the transformation was done properly by the class designer.

            // Change from 4/41 to 3/31
            SetType(3);
            // Reset the proxy.
            fSTLtype = kNone;
            switch(fStreamerType) {
               case TVirtualStreamerInfo::kAny:
               case TVirtualStreamerInfo::kSTL:
                  fStreamerType = TVirtualStreamerInfo::kObject;
                  break;
               case TVirtualStreamerInfo::kAnyp:
               case TVirtualStreamerInfo::kSTLp:
                  fStreamerType = TVirtualStreamerInfo::kObjectp;
                  break;
               case TVirtualStreamerInfo::kAnyP:
                  fStreamerType = TVirtualStreamerInfo::kObjectP;
                  break;
            }
            fClonesClass = oldProxy->GetValueClass();
            fClonesName = fClonesClass->GetName();
            delete fCollProxy;
            fCollProxy = 0;
            TClass* clm = fClonesClass;
            if (clm) {
               clm->BuildRealData(); //just in case clm derives from an abstract class
               clm->GetStreamerInfo();
            }
            SwitchContainer(GetListOfBranches());
            SetReadLeavesPtr();
            SetFillLeavesPtr();
            delete fIterators;
            fIterators = 0;
            delete fPtrIterators;
            fPtrIterators =0;
         } else {
            // FIXME: We must maintain fObject here as well.
            Error("SetAddress","For %s can not convert %s into %s\n",GetName(),GetCurrentClass()->GetName(),newType->GetName());
            fAddress = 0;
            return;
         }
      } else {
         if (!fIterators && !fPtrIterators) {
            if(fSTLtype != ROOT::kSTLvector && GetCollectionProxy()->HasPointers() && fSplitLevel > TTree::kSplitCollectionOfPointers ) {
               fPtrIterators = new TVirtualCollectionPtrIterators(GetCollectionProxy());
            } else if (fCollProxy->GetProperties() & TVirtualCollectionProxy::kIsAssociative) {
               fWriteIterators = new TVirtualCollectionIterators(fCollProxy,kFALSE);
               fIterators = new TVirtualCollectionIterators(fCollProxy);
            } else {
               fIterators = new TVirtualCollectionIterators(GetCollectionProxy());
            }
         }
      }
   }

   //
   //  Establish the semantics of fObject and fAddress.
   //
   //  Top-level branch:
   //       fObject is a ptr to the object,
   //       fAddress is a ptr to a pointer to the object.
   //
   //  Sub-branch:
   //       fObject is a ptr to the object,
   //       fAddress is the same as fObject.
   //
   //
   //  There are special cases for TClonesArray and STL containers.
   //  If there is no user-provided object, we allocate one.  We must
   //  also initialize any STL container proxy.
   //

   if (fType == 3) {
      // -- We are a TClonesArray master branch.
      if (fAddress) {
         // -- We have been given a non-zero address, allocate if necessary.
         if (fStreamerType == TVirtualStreamerInfo::kObject) {
            // -- We are *not* a top-level branch and we are *not* a pointer to a TClonesArray.
            // Case of an embedded TClonesArray.
            fObject = fAddress;
            // Check if it has already been properly built.
            TClonesArray* clones = (TClonesArray*) fObject;
            if (!clones->GetClass()) {
               new(fObject) TClonesArray(fClonesClass);
            }
         } else {
            // -- We are either a top-level branch or we are a subbranch which is a pointer to a TClonesArray.
            // Streamer type should be -1 (for a top-level branch) or kObject(p|P) here.
            if ((fStreamerType != -1) &&
                (fStreamerType != TVirtualStreamerInfo::kObjectp) &&
                (fStreamerType != TVirtualStreamerInfo::kObjectP)) {
               Error("SetAddress", "TClonesArray with fStreamerType: %d", fStreamerType);
            } else if (fStreamerType == -1) {
               // -- We are a top-level branch.
               TClonesArray** pp = (TClonesArray**) fAddress;
               if (!*pp) {
                  // -- Caller wants us to allocate the clones array, but they will own it.
                  *pp = new TClonesArray(fClonesClass);
               }
               fObject = (char*) *pp;
            } else {
               // -- We are a pointer to a TClonesArray.
               // Note: We do this so that the default constructor,
               //       or the i/o constructor can be lazy.
               TClonesArray** pp = (TClonesArray**) fAddress;
               if (!*pp) {
                  // -- Caller wants us to allocate the clones array, but they will own it.
                  *pp = new TClonesArray(fClonesClass);
               }
               fObject = (char*) *pp;
            }
         }
      } else {
         // -- We have been given a zero address, allocate for top-level only.
         if (fStreamerType == TVirtualStreamerInfo::kObject) {
            // -- We are *not* a top-level branch and we are *not* a pointer to a TClonesArray.
            // Case of an embedded TClonesArray.
            Error("SetAddress", "Embedded TClonesArray given a zero address for branch '%s'", GetName());
         } else {
            // -- We are either a top-level branch or we are a subbranch which is a pointer to a TClonesArray.
            // Streamer type should be -1 (for a top-level branch) or kObject(p|P) here.
            if ((fStreamerType != -1) &&
                (fStreamerType != TVirtualStreamerInfo::kObjectp) &&
                (fStreamerType != TVirtualStreamerInfo::kObjectP)) {
               Error("SetAddress", "TClonesArray with fStreamerType: %d", fStreamerType);
            } else if (fStreamerType == -1) {
               // -- We are a top-level branch.
               // Idea: Consider making a zero address not allocate.
               SetBit(kDeleteObject);
               fObject = (char*) new TClonesArray(fClonesClass);
               fAddress = (char*) &fObject;
            } else {
               // -- We are a sub-branch which is a pointer to a TClonesArray.
               Error("SetAddress", "Embedded pointer to a TClonesArray given a zero address for branch '%s'", GetName());
            }
         }
      }
   } else if (fType == 4) {
      // -- We are an STL container master branch.
      //
      // Initialize fCollProxy.
      TVirtualCollectionProxy* proxy = GetCollectionProxy();
      if (fAddress) {
         // -- We have been given a non-zero address, allocate if necessary.
         if ((fStreamerType == TVirtualStreamerInfo::kObject) ||
             (fStreamerType == TVirtualStreamerInfo::kAny) ||
             (fStreamerType == TVirtualStreamerInfo::kSTL)) {
            // We are *not* a top-level branch and we are *not* a pointer to an STL container.
            // Case of an embedded STL container.
            // Note: We test for the kObject and kAny types to support
            //       the (unwise) choice of inheriting from an STL container.
            fObject = fAddress;
         } else {
            // We are either a top-level branch or subbranch which is a pointer to an STL container.
            // Streamer type should be -1 (for a top-level branch) or kSTLp here.
            if ((fStreamerType != -1) && (fStreamerType != TVirtualStreamerInfo::kSTLp)) {
               Error("SetAddress", "STL container with fStreamerType: %d", fStreamerType);
            } else if (fStreamerType == -1) {
               // -- We are a top-level branch.
               void** pp = (void**) fAddress;
               if (!*pp) {
                  // -- Caller wants us to allocate the STL container, but they will own it.
                  *pp = proxy->New();
                  if (!(*pp)) {
                     Error("SetAddress", "Failed to allocate STL container for branch '%s'", GetName());
                     // FIXME: Should we do this?  Lots of other code wants
                     //        fAddress to be zero if no fObject, but is
                     //        that a good thing?
                     fAddress = 0;
                  }
               }
               fObject = (char*) *pp;
            } else {
               // -- We are a pointer to an STL container.
               // Note: We do this so that the default constructor,
               //       or the i/o constructor can be lazy.
               void** pp = (void**) fAddress;
               if (!*pp) {
                  // -- Caller wants us to allocate the STL container, but they will own it.
                  *pp = proxy->New();
                  if (!(*pp)) {
                     Error("SetAddress", "Failed to allocate STL container for branch '%s'", GetName());
                     // FIXME: Should we do this?  Lots of other code wants
                     //        fAddress to be zero if no fObject, but is
                     //        that a good thing?
                     fAddress = 0;
                  }
               }
               fObject = (char*) *pp;
            }
         }
      } else {
         // -- We have been given a zero address, allocate for top-level only.
         if ((fStreamerType == TVirtualStreamerInfo::kObject) ||
             (fStreamerType == TVirtualStreamerInfo::kAny) ||
             (fStreamerType == TVirtualStreamerInfo::kSTL)) {
            // We are *not* a top-level branch and we are *not* a pointer to an STL container.
            // Case of an embedded STL container.
            // Note: We test for the kObject and kAny types to support
            //       the (unwise) choice of inheriting from an STL container.
            Error("SetAddress", "Embedded STL container given a zero address for branch '%s'", GetName());
         } else {
            // We are either a top-level branch or sub-branch which is a pointer to an STL container.
            // Streamer type should be -1 (for a top-level branch) or kSTLp here.
            if ((fStreamerType != -1) && (fStreamerType != TVirtualStreamerInfo::kSTLp)) {
               Error("SetAddress", "STL container with fStreamerType: %d", fStreamerType);
            } else if (fStreamerType == -1) {
               // -- We are a top-level branch, allocate.
               SetBit(kDeleteObject);
               fObject = (char*) proxy->New();
               if (fObject) {
                  fAddress = (char*) &fObject;
               } else {
                  Error("SetAddress", "Failed to allocate STL container for branch '%s'", GetName());
                  // FIXME: Should we do this?  Lots of other code wants
                  //        fAddress to be zero if no fObject, but is
                  //        that a good thing?
                  fAddress = 0;
               }
            } else {
               // -- We are a sub-branch which is a pointer to an STL container.
               Error("SetAddress", "Embedded pointer to an STL container given a zero address for branch '%s'", GetName());
            }
         }
      }
   } else if (fType == 41) {
      // -- We are an STL container sub-branch.
      // Initialize fCollProxy.
      GetCollectionProxy();
      // We are not at top-level branch.
      fObject = fAddress;
   } else if (fID < 0) {
      // -- We are a top-level branch.
      char** pp = (char**) fAddress;
      if (pp && *pp) {
         // -- Caller provided an i/o buffer for us to use.
         fObject = *pp;
      } else {
         // -- Caller did not provide an i/o buffer for us to use, we must make one for ourselves.
         if (clOfBranch) {
            if (!pp) {
               // -- Caller wants us to own the object.
               SetBit(kDeleteObject);
            }
            fObject = (char*) clOfBranch->New();
            if (pp) {
               *pp = fObject;
            } else {
               fAddress = (char*) &fObject;
            }
         } else {
            Error("SetAddress", "I have no TClass for branch %s, so I cannot allocate an I/O buffer!", GetName());
            if (pp) {
               fObject = 0;
               *pp = 0;
            }
         }
      }
   } else {
      // -- We are *not* a top-level branch.
      fObject = fAddress;
   }

   if (!info) {
      // FIXME: We need and error message here, no streamer info, so cannot set offsets.
      return;
   }

   // We do this only once because it depends only on
   // the type of our object, not on its address.
   if (!fInitOffsets) {
      InitializeOffsets();
   }

   // We are split, recurse down to our sub-branches.
   //
   // FIXME: This is a tail recursion, we burn stack.
   Int_t nbranches = fBranches.GetEntriesFast();
   for (Int_t i = 0; i < nbranches; ++i) {
      TBranch* abranch = (TBranch*) fBranches.UncheckedAt(i);
      // FIXME: This is a tail recursion!
      if (fBranchOffset[i] != TStreamerInfo::kMissing) {
         abranch->SetAddress(fObject + fBranchOffset[i]);
         abranch->SetBit(kAddressSet);
      } else {
         // When the member is missing, just leave the address alone
         // (since setting explicitly to 0 would trigger error/warning
         // messages).
         // abranch->SetAddress(0);
         abranch->SetBit(kAddressSet);
      }
   }
}

//______________________________________________________________________________
void TBranchElement::SetBasketSize(Int_t buffsize)
{
   // -- Reset the basket size for all sub-branches of this branch element.

   TBranch::SetBasketSize(buffsize);
   Int_t nbranches = fBranches.GetEntriesFast();
   for (Int_t i = 0; i < nbranches; ++i) {
      TBranch* branch = (TBranch*) fBranches[i];
      branch->SetBasketSize(fBasketSize);
   }
}

//______________________________________________________________________________
void TBranchElement::SetBranchCount(TBranchElement* brOfCounter)
{
   // -- Set the branch counter for this branch.

   fBranchCount = brOfCounter;
   if (fBranchCount==0) return;

   TLeafElement* leafOfCounter  = (TLeafElement*) brOfCounter->GetListOfLeaves()->At(0);
   TLeafElement* leaf = (TLeafElement*) GetListOfLeaves()->At(0);
   if (leafOfCounter && leaf) {
      leaf->SetLeafCount(leafOfCounter);
   } else {
      if (!leafOfCounter) {
         Warning("SetBranchCount", "Counter branch %s for branch %s has no leaves!", brOfCounter->GetName(), GetName());
      }
      if (!leaf) {
         Warning("SetBranchCount", "Branch %s has no leaves!", GetName());
      }
   }
}

//______________________________________________________________________________
Bool_t TBranchElement::SetMakeClass(Bool_t decomposeObj)
{
   // Set the branch in a mode where the object are decomposed
   // (Also known as MakeClass mode).
   // Return whether the setting was possible (it is not possible for
   // TBranch and TBranchObject).

   if (decomposeObj)
      SetBit(kDecomposedObj);   // Same as SetBit(kMakeClass)
   else
      ResetBit(kDecomposedObj);

   Int_t nbranches = fBranches.GetEntriesFast();
   for (Int_t i = 0; i < nbranches; ++i) {
      TBranchElement* branch = (TBranchElement*) fBranches[i];
      branch->SetMakeClass(decomposeObj);
   }
   SetReadLeavesPtr();
   SetFillLeavesPtr();

   return kTRUE;
}

//______________________________________________________________________________
void TBranchElement::SetObject(void* obj)
{
   // Set object this branch is pointing to.

   if (TestBit(kDoNotProcess)) {
      return;
   }
   fObject = (char*)obj;
   SetAddress( &fObject );
}

//______________________________________________________________________________
void TBranchElement::SetOffset(Int_t offset)
{
   // Set offset of the object (to which the data member represented by this
   // branch belongs) inside its containing object (if any).

   // We need to make sure that the Read and Write action's configuration
   // properly reflect this value.

   if (fReadActionSequence) {
      fReadActionSequence->AddToOffset(offset - fOffset);
   }
   if (fFillActionSequence) {
      fFillActionSequence->AddToOffset(offset - fOffset);
   }
   fOffset = offset;
}

//______________________________________________________________________________
void TBranchElement::SetReadActionSequence()
{
   // Set the sequence of actions needed to read the data out of the buffer.

   if (fInfo == 0) {
      // We are called too soon.  We will be called again by InitInfo
      return;
   }

   // Get the action sequence we need to copy for reading.
   TStreamerInfoActions::TActionSequence *original = 0;
   TStreamerInfoActions::TActionSequence *transient = 0;
   if (fType == 41) {
      if( fSplitLevel >= TTree::kSplitCollectionOfPointers && fBranchCount->fSTLtype == ROOT::kSTLvector) {
         original = fInfo->GetReadMemberWiseActions(kTRUE);
      } else {
         TVirtualStreamerInfo *info = GetInfoImp();
         if (GetParentClass() == info->GetClass()) {
            if( fTargetClass.GetClassName()[0] && fBranchClass != fTargetClass ) {
               original = GetCollectionProxy()->GetConversionReadMemberWiseActions(fBranchClass.GetClass(), fClassVersion);
            } else {
               original = GetCollectionProxy()->GetReadMemberWiseActions(fClassVersion);
            }
         } else if (GetCollectionProxy()) {
            // Base class and embedded objects.

            transient = TStreamerInfoActions::TActionSequence::CreateReadMemberWiseActions(info,*GetCollectionProxy());
            original = transient;
         }
      }
   } else if (fType == 31) {
      original = fInfo->GetReadMemberWiseActions(kTRUE);
   } else if (0<=fType && fType<=2) {
      // Note: this still requires the ObjectWise sequence to not be optimized!
      original = fInfo->GetReadMemberWiseActions(kFALSE);
   }
   if (original) {
      fIDs.insert(fIDs.begin(),fID); // Include the main element in the sequence.
      if (fReadActionSequence) delete fReadActionSequence;
      fReadActionSequence = original->CreateSubSequence(fIDs,fOffset);
      fIDs.erase(fIDs.begin());
   }
   delete transient;
}

//______________________________________________________________________________
void TBranchElement::SetReadLeavesPtr()
{
   // Set the ReadLeaves pointer to execute the expected operations.

   if (TestBit(kDecomposedObj)) {
      fReadLeaves = (ReadLeaves_t)&TBranchElement::ReadLeavesMakeClass;
   } else if (fType == 4) {
      fReadLeaves = (ReadLeaves_t)&TBranchElement::ReadLeavesCollection;
   } else if (fType == 41) {
      if( fSplitLevel >= TTree::kSplitCollectionOfPointers ) {
         if (fBranchCount->fSTLtype == ROOT::kSTLvector) {
            fReadLeaves = (ReadLeaves_t)&TBranchElement::ReadLeavesCollectionSplitVectorPtrMember;
         } else {
            fReadLeaves = (ReadLeaves_t)&TBranchElement::ReadLeavesCollectionSplitPtrMember;
         }
      } else {
         fReadLeaves = (ReadLeaves_t)&TBranchElement::ReadLeavesCollectionMember;
      }
   } else if (fType == 3) {
      fReadLeaves = (ReadLeaves_t)&TBranchElement::ReadLeavesClones;
   } else if (fType == 31) {
      fReadLeaves = (ReadLeaves_t)&TBranchElement::ReadLeavesClonesMember;
   } else if (fType < 0) {
      fReadLeaves = (ReadLeaves_t)&TBranchElement::ReadLeavesCustomStreamer;
   } else if (fType <=2) {
      // split-class branch, base class branch, data member branch, or top-level branch.
      if (fBranchCount) {
         fReadLeaves = (ReadLeaves_t)&TBranchElement::ReadLeavesMemberBranchCount;
      } else if (fStreamerType == TVirtualStreamerInfo::kCounter) {
         fReadLeaves = (ReadLeaves_t)&TBranchElement::ReadLeavesMemberCounter;
      } else {
         fReadLeaves = (ReadLeaves_t)&TBranchElement::ReadLeavesMember;
      }
   } else {
      Fatal("SetReadLeavePtr","Unexpected branch type %d for %s",fType,GetName());
   }

   SetReadActionSequence();
}

//______________________________________________________________________________
void TBranchElement::SetFillActionSequence()
{
   // Set the sequence of actions needed to write the data out from the buffer.

   if (fInfo == 0) {
      // We are called too soon.  We will be called again by InitInfo
      return;
   }

   // Get the action sequence we need to copy for reading.
   TStreamerInfoActions::TActionSequence *original = 0;
   TStreamerInfoActions::TActionSequence *transient = 0;
   if (fType == 41) {
      if( fSplitLevel >= TTree::kSplitCollectionOfPointers && fBranchCount->fSTLtype == ROOT::kSTLvector) {
         original = fInfo->GetWriteMemberWiseActions(kTRUE);
      } else {
         TVirtualStreamerInfo *info = GetInfoImp();
         if (GetParentClass() == info->GetClass()) {
            //if( fTargetClass.GetClassName()[0] && fBranchClass != fTargetClass ) {
            //   original = GetCollectionProxy()->GetConversionWriteMemberWiseActions(fBranchClass.GetClass());
            //} else {
            original = GetCollectionProxy()->GetWriteMemberWiseActions();
            //}
         } else if (GetCollectionProxy()) {
            // Base class and embedded objects.

            transient = TStreamerInfoActions::TActionSequence::CreateWriteMemberWiseActions(info,*GetCollectionProxy());
            original = transient;
         }
      }
   } else if (fType == 31) {
      original = fInfo->GetWriteMemberWiseActions(kTRUE);
   } else if (0<=fType && fType<=2) {
      // Note: this still requires the ObjectWise sequence to not be optimized!
      original = fInfo->GetWriteMemberWiseActions(kFALSE);
   }
   if (original) {
      fIDs.insert(fIDs.begin(),fID); // Include the main element in the sequence.
      if (fFillActionSequence) delete fFillActionSequence;
      fFillActionSequence = original->CreateSubSequence(fIDs,fOffset);
      fIDs.erase(fIDs.begin());
   }
   delete transient;

}

//______________________________________________________________________________
void TBranchElement::SetFillLeavesPtr()
{
   // Set the FillLeaves pointer to execute the expected operations.

   if (fTree->GetMakeClass() && ((fType==3)||(fType==31))) {
      fFillLeaves = (FillLeaves_t)&TBranchElement::FillLeavesMakeClass;
   } else if (fType == 4) {
      fFillLeaves = (FillLeaves_t)&TBranchElement::FillLeavesCollection;
   } else if (fType == 41) {
      if( fSplitLevel >= TTree::kSplitCollectionOfPointers ) {
         if (fBranchCount->fSTLtype == ROOT::kSTLvector) {
            fFillLeaves = (FillLeaves_t)&TBranchElement::FillLeavesCollectionSplitVectorPtrMember;
         } else {
            fFillLeaves = (FillLeaves_t)&TBranchElement::FillLeavesCollectionSplitPtrMember;
         }
      } else if (GetCollectionProxy()->GetProperties() & TVirtualCollectionProxy::kIsAssociative) {
         fFillLeaves = (FillLeaves_t)&TBranchElement::FillLeavesAssociativeCollectionMember;
      } else {
         fFillLeaves = (FillLeaves_t)&TBranchElement::FillLeavesCollectionMember;
      }
   } else if (fType == 3) {
      fFillLeaves = (FillLeaves_t)&TBranchElement::FillLeavesClones;
   } else if (fType == 31) {
      fFillLeaves = (FillLeaves_t)&TBranchElement::FillLeavesClonesMember;
   } else if (fType < 0) {
      fFillLeaves = (FillLeaves_t)&TBranchElement::FillLeavesCustomStreamer;
   } else if (fType <=2) {
      //split-class branch, base class branch, data member branch, or top-level branch.
      if (fBranchCount) {
         fFillLeaves = (FillLeaves_t)&TBranchElement::FillLeavesMemberBranchCount;
      } else if (fStreamerType == TVirtualStreamerInfo::kCounter) {
         fFillLeaves = (FillLeaves_t)&TBranchElement::FillLeavesMemberCounter;
      } else {
         fFillLeaves = (FillLeaves_t)&TBranchElement::FillLeavesMember;
      }
   } else {
      Fatal("SetFillLeavePtr","Unexpected branch type %d for %s",fType,GetName());
   }

   SetFillActionSequence();
}

//______________________________________________________________________________
void TBranchElement::SetTargetClass(const char *name)
{
   // Set the name of the class of the in-memory object into which the data will
   // loaded.

   if (name == 0) return;

   if (strcmp(fTargetClass.GetClassName(),name) != 0 )
   {
      // We are changing target class, let's reset the meta information and
      // the sub-branches.

      fInfo = 0;
      fInit = kFALSE;
      fInitOffsets = kFALSE;
      delete fReadActionSequence;
      fReadActionSequence = 0;
      delete fFillActionSequence;
      fFillActionSequence = 0;

      Int_t nbranches = fBranches.GetEntriesFast();
      for (Int_t i = 0; i < nbranches; ++i) {
         TBranchElement *sub = (TBranchElement*) fBranches[i];
         if (sub->fTargetClass == fTargetClass ) {
            sub->SetTargetClass(name);
         }
         if (sub->fParentClass == fTargetClass ) {
            sub->SetParentClass(TClass::GetClass(name));
         }
      }
      fTargetClass = name;
   }

}

//______________________________________________________________________________
void TBranchElement::SetupAddresses()
{
   // -- If the branch address is not set,  we set all addresses starting with
   // the top level parent branch.  This is required to be done in order for
   // GetOffset to be correct and for GetEntry to run.

   // Check to see if the user changed the branch address on us.
   ValidateAddress();

   if (fAddress || fTree->GetMakeClass()) {
      // -- Do nothing if already setup or if we are a MakeClass tree.
      return;
   }
   SetupAddressesImpl();
}

//______________________________________________________________________________
void TBranchElement::SetupAddressesImpl()
{
   // -- If the branch address is not set,  we set all addresses starting with
   // the top level parent branch.  This is required to be done in order for
   // GetOffset to be correct and for GetEntry to run.

   if (TestBit(kDoNotProcess|kAddressSet)) {
      // -- Do nothing if we have been told not to.
      // Or the data member in this branch is not longer part of the
      // parent's layout.
      return;
   }

   //--------------------------------------------------------------------------
   // Check if we are splited STL collection of pointers
   //--------------------------------------------------------------------------
   if( fType == 41 && fSplitLevel >= TTree::kSplitCollectionOfPointers )
   {
      TBranchElement *parent = (TBranchElement *)GetMother()->GetSubBranch( this );

      // Make sure the StreamerInfo is loaded and initialized.
      GetInfoImp();

      if( !parent->GetAddress() )
         parent->SetAddress( 0 );
      return;
   }

   //--------------------------------------------------------------------------
   // Any other case
   //--------------------------------------------------------------------------
   TBranchElement* mother = (TBranchElement*) GetMother();
   if (!mother) {
      return;
   }
   TClass* cl = TClass::GetClass(mother->GetClassName());

   // Make sure the StreamerInfo is loaded and initialized.
   GetInfoImp();

   if (!cl) {
      return;
   }

   if (!mother->GetAddress()) {
      // -- Our top-level branch has no address.
      Bool_t motherStatus = mother->TestBit(kDoNotProcess);
      mother->ResetBit(kDoNotProcess);
      // Note: This will allocate an object.
      mother->SetAddress(0);
      mother->SetBit(kDoNotProcess, motherStatus);
   }
}

//______________________________________________________________________________
void TBranchElement::Streamer(TBuffer& R__b)
{
   // -- Stream an object of class TBranchElement.
   if (R__b.IsReading()) {
      R__b.ReadClassBuffer(TBranchElement::Class(), this);
      fParentClass.SetName(fParentName);
      fBranchClass.SetName(fClassName);
      fTargetClass.SetName(fClassName);
      fClonesClass.SetName(fClonesName);
      // The fAddress and fObject data members are not persistent,
      // therefore we do not own anything.
      // Also clear the bit possibly set by the schema evolution.
      ResetBit(kDeleteObject|kCache|kOwnOnfileObj|kAddressSet);
      // Fixup a case where the TLeafElement was missing
      if ((fType == 0) && (fLeaves.GetEntriesFast() == 0)) {
         TLeaf* leaf = new TLeafElement(this, GetTitle(), fID, fStreamerType);
         leaf->SetTitle(GetTitle());
         fNleaves = 1;
         fLeaves.Add(leaf);
         fTree->GetListOfLeaves()->Add(leaf);
      }
      // SetReadLeavesPtr();
   }
   else {
      TDirectory* dirsav = fDirectory;
      fDirectory = 0;  // to avoid recursive calls
      {
         // Save class version.
         Int_t classVersion = fClassVersion;
         // Record only positive 'version number'
         if (fClassVersion < 0) {
            fClassVersion = -fClassVersion;
         }
         // TODO: Should we clear the kDeleteObject bit before writing?
         //       If we did we would have to remember the old value and
         //       put it back, we wouldn't want to forget that we owned
         //       something just because we got written to disk.
         R__b.WriteClassBuffer(TBranchElement::Class(), this);
         // Restore class version.
         fClassVersion = classVersion;
      }
      //
      //  Mark all streamer infos used by this branch element
      //  to be written to our output file.
      //
      {
         R__b.ForceWriteInfo(GetInfoImp(), kTRUE);
      }
      //
      //  If we are a clones array master branch, or an
      //  STL container master branch, we must also mark
      //  the streamer infos used by the value class to
      //  be written to our output file.
      //
      if (fType == 3) {
         // -- TClonesArray, counter/master branch
         //
         //  We must mark the streamer info for the
         //  value class to be written to the file.
         //
         TClass* cl = fClonesClass;
         if (cl) {
            R__b.ForceWriteInfo(cl->GetStreamerInfo(), kTRUE);
         }
      }
      else if (fType == 4) {
         // -- STL container, counter/master branch
         //
         //  We must mark the streamer info for the
         //  value class to be written to the file.
         //
         TVirtualCollectionProxy* cp = GetCollectionProxy();
         if (cp) {
            TClass* cl = cp->GetValueClass();
            if (cl) {
               R__b.ForceWriteInfo(cl->GetStreamerInfo(), kTRUE);
            }
         }
      }
      // If we are in a separate file, then save
      // ourselves as an independent key.
      if (!dirsav) {
         // Note: No need to restore fDirectory, it was already zero.
         return;
      }
      if (!dirsav->IsWritable()) {
         fDirectory = dirsav;
         return;
      }
      TDirectory* pdirectory = fTree->GetDirectory();
      if (!pdirectory) {
         fDirectory = dirsav;
         return;
      }
      const char* treeFileName = pdirectory->GetFile()->GetName();
      TBranch* mother = GetMother();
      const char* motherFileName = treeFileName;
      if (mother && (mother != this)) {
         motherFileName = mother->GetFileName();
      }
      if ((fFileName.Length() > 0) && strcmp(motherFileName, fFileName.Data())) {
         dirsav->WriteTObject(this);
      }
      fDirectory = dirsav;
   }
}

//______________________________________________________________________________
Int_t TBranchElement::Unroll(const char* name, TClass* clParent, TClass* cl, char* ptr, Int_t basketsize, Int_t splitlevel, Int_t btype)
{
   // -- Split class cl into sub-branches of this branch.
   //
   // Create a sub-branch of this branch for each non-empty,
   // non-abstract base class of cl (unless we are a sub-branch
   // of a TClonesArray or an STL container, in which case we
   // do *not* create a sub-branch), and for each non-split data
   // member of cl.
   //
   // Note: We do *not* create sub-branches for base classes of cl
   //       if we are a sub-branch of a TClonesArray or an STL container.
   //
   // Note: We do *not* create sub-branches for data members which
   //       have a class type and which we are splitting.
   //
   // Note: The above rules imply that the branch heirarchy increases
   //       in depth only for base classes of cl (unless we are inside
   //       of a TClonesArray or STL container, in which case the depth
   //       does *not* increase, the base class is elided) and for
   //       TClonesArray or STL container data members (which have one
   //       additional level of sub-branches).  The only other way the
   //       depth increases is when the top-level branch has a split
   //       class data member, in that case the constructor will create
   //       a sub-branch for it.  In other words, the interior nodes of
   //       the branch tree are all either: base class nodes; split
   //       class nodes which are direct sub-branches of top-level nodes
   //       (created by TClass::Bronch usually); or TClonesArray or STL
   //       container master nodes.
   //
   // Note: The exception to the above is for the top-level branches,
   //       Tree::Bronch creates nodes for everything in that case,
   //       except for a TObject base class of a class which has the
   //       can ignore tobject streamer flag set.

   //----------------------------------------------------------------------------
   // Handling the case of STL collections of pointers
   //----------------------------------------------------------------------------
   Int_t splitSTLP = splitlevel - (splitlevel%TTree::kSplitCollectionOfPointers);
   splitlevel %= TTree::kSplitCollectionOfPointers;


   TString branchname;

   if ((cl == TObject::Class()) && clParent->CanIgnoreTObjectStreamer()) {
      return 0;
   }

   TStreamerInfo* sinfo = fTree->BuildStreamerInfo(cl);

   //
   //  Do nothing if we couldn't build the streamer info for cl.
   //

   if (!sinfo) {
      return 0;
   }

   Int_t ndata = sinfo->GetNelement();

   if ((ndata == 1) && cl->GetCollectionProxy() && !strcmp(sinfo->GetElement(0)->GetName(), "This")) {
      // -- Class cl is an STL collection, refuse to split it.
      // Question: Why?  We certainly could by switching to the value class.
      // Partial Answer: Only the branch element constructor can split STL containers.
      return 1;
   }

   for (Int_t elemID = 0; elemID < ndata; ++elemID) {
      // -- Loop over all the streamer elements and create sub-branches as needed.
      TStreamerElement* elem = sinfo->GetElement(elemID);
      if (elem->IsA() == TStreamerArtificial::Class()) {
         continue;
      }
      if (elem->TestBit(TStreamerElement::kRepeat)) {
         continue;
      }
      if (elem->TestBit(TStreamerElement::kCache) && !elem->TestBit(TStreamerElement::kWrite)) {
         continue;
      }
      Int_t offset = elem->GetOffset();
      // FIXME: An STL container as a base class gets TStreamerSTL as its class, so this test is not enough.
      // See InitializeOffsets() for the proper test.
      if (elem->IsA() == TStreamerBase::Class()) {
         // -- This is a base class of cl.
         TClass* clOfBase = TClass::GetClass(elem->GetName());
         if ((clOfBase->Property() & kIsAbstract) && cl->InheritsFrom(TCollection::Class())) {
            // -- Do nothing if we are one of the abstract collection (we know they have no data).
            return -1;
         }
         if ((btype == 31) || (btype == 41)) {
            // -- Elide the base-class sub-branches of a split TClonesArray or STL container.
            //
            // Note: We are eliding the base class here, that is, we never
            //       create a branch for it, so the branch heirarchy is not
            //       complete.
            // Note: The clParent parameter is the value class of the
            //       container which we are splitting.  It does not
            //       appear in the branch heirarchy either.
            // Note: We can use parent class (clParent) != branch class (elemClass) to detection elision.
            Int_t unroll = -1;
            if (!elem->CannotSplit() || clOfBase == TObject::Class()) {
               unroll = Unroll(name, clParent, clOfBase, ptr + offset, basketsize, splitlevel+splitSTLP, btype);
            }
            if (unroll < 0) {
               // FIXME: We could not split because we are abstract, should we be doing this?
               if (strlen(name)) {
                  branchname.Form("%s.%s", name, elem->GetFullName());
               } else {
                  branchname.Form("%s", elem->GetFullName());
               }
               TBranchElement* branch = new TBranchElement(this, branchname, sinfo, elemID, 0, basketsize, 0, btype);
               branch->SetParentClass(clParent);
               fBranches.Add(branch);
            }
         } else if (clOfBase->GetListOfRealData()->GetSize()) {
            // -- Create a branch for a non-empty base class.
            if (strlen(name)) {
               branchname.Form("%s.%s", name, elem->GetFullName());
               // Elide the base class name when creating the sub-branches.
               // Note: The branch names for sub-branches of a base class branch
               //       do not represent the full class heirarchy because we do
               //       this, however it does keep the branch names for the
               //       inherited data members simple.
               TBranchElement* branch = new TBranchElement(this, name, sinfo, elemID, ptr + offset, basketsize, splitlevel+splitSTLP, btype);
               // Then reset it to the proper name.
               branch->SetName(branchname);
               branch->SetTitle(branchname);
               branch->SetParentClass(clParent);
               fBranches.Add(branch);
            } else {
               branchname.Form("%s", elem->GetFullName());
               TBranchElement* branch = new TBranchElement(this, branchname, sinfo, elemID, ptr + offset, basketsize, splitlevel+splitSTLP, btype);
               branch->SetParentClass(clParent);
               fBranches.Add(branch);
            }
         }
      } else {
         // -- This is a data member of cl.
         if (strlen(name)) {
            branchname.Form("%s.%s", name, elem->GetFullName());
         } else {
            branchname.Form("%s", elem->GetFullName());
         }
         if ((splitlevel > 1) && ((elem->IsA() == TStreamerObject::Class()) || (elem->IsA() == TStreamerObjectAny::Class()))) {
            // -- We are splitting a non-TClonesArray (may inherit from TClonesArray though), non-STL container object.
            //
            // Ignore an abstract class.
            // FIXME: How could an abstract class get here?
            //        Partial answer: It is a base class.  But this is a data member!
            TClass* elemClass = TClass::GetClass(elem->GetTypeName());
            if (elemClass->Property() & kIsAbstract) {
               return -1;
            }
            if (elem->CannotSplit()) {
               // We are not splitting.
               TBranchElement* branch = new TBranchElement(this, branchname, sinfo, elemID, ptr + offset, basketsize, 0, btype);
               branch->SetParentClass(clParent);
               fBranches.Add(branch);
            } else if (elemClass->InheritsFrom(TClonesArray::Class())) {
               // Splitting something derived from TClonesArray.
               Int_t subSplitlevel = splitlevel-1;
               if (btype == 31 || btype == 41 || elem->CannotSplit()) {
                  // -- We split the sub-branches of a TClonesArray or an STL container only once.
                  subSplitlevel = 0;
               }
               TBranchElement* branch = new TBranchElement(this, branchname, sinfo, elemID, ptr + offset, basketsize, subSplitlevel, btype);
               branch->SetParentClass(clParent);
               fBranches.Add(branch);
            } else {
               // Splitting a normal class.
               // FIXME: We are eliding the class we are splitting here,
               //        i.e., we do not create a branch for it, so the
               //        branch heirarchy does not match the class heirarchy.
               // Note: clParent is the class which contains a data member of
               //       the class type which we are splitting.
               // Note: We can use parent class (clParent) != branch class (elemClass) to detection elision.
               Int_t unroll = Unroll(branchname, clParent, elemClass, ptr + offset, basketsize, splitlevel-1+splitSTLP, btype);
               if (unroll < 0) {
                  // FIXME: We could not split because we are abstract, should we be doing this?
                  TBranchElement* branch = new TBranchElement(this, branchname, sinfo, elemID, ptr + offset, basketsize, 0, btype);
                  branch->SetParentClass(clParent);
                  fBranches.Add(branch);
               }
            }
         }
         else if( elem->GetClassPointer() &&
                 elem->GetClassPointer()->GetCollectionProxy() &&
                 elem->GetClassPointer()->GetCollectionProxy()->HasPointers() &&
                 splitSTLP && fType != 4 )
         {

            TBranchSTL* branch = new TBranchSTL( this, branchname,
                                                elem->GetClassPointer()->GetCollectionProxy(),
                                                basketsize, splitlevel - 1+splitSTLP, sinfo, elemID );
            branch->SetAddress( ptr+offset );
            fBranches.Add( branch );
         }
         else if ((elem->IsA() == TStreamerSTL::Class()) && !elem->IsaPointer()) {
            // -- We have an STL container.
            // Question: What if splitlevel == 0 here?
            // Answer: then we should not be here.
            Int_t subSplitlevel = splitlevel - 1;
            if ((btype == 31) || (btype == 41) || elem->CannotSplit()) {
               // -- We split the sub-branches of a TClonesArray or an STL container only once.
               subSplitlevel = 0;
            }
            TBranchElement* branch = new TBranchElement(this, branchname, sinfo, elemID, ptr + offset, basketsize, subSplitlevel+splitSTLP, btype);
            branch->SetParentClass(clParent);
            fBranches.Add(branch);
         } else if (((btype != 31) && (btype != 41)) && ptr && ((elem->GetClassPointer() == TClonesArray::Class()) || ((elem->IsA() == TStreamerSTL::Class()) && !elem->CannotSplit()))) {
            // -- We have a TClonesArray.
            // FIXME: We could get a ptr to a TClonesArray here by mistake.
            // Question: What if splitlevel == 0 here?
            // Answer: then we should not be here.
            // Note: ptr may be null in case of a TClonesArray inside another
            //       TClonesArray or STL container, see the else clause.
            TBranchElement* branch = new TBranchElement(this, branchname, sinfo, elemID, ptr + offset, basketsize, splitlevel-1+splitSTLP, btype);
            branch->SetParentClass(clParent);
            fBranches.Add(branch);
         } else {
            // -- We are not going to split this element any farther.
            TBranchElement* branch = new TBranchElement(this, branchname, sinfo, elemID, 0, basketsize, splitSTLP, btype);
            branch->SetType(btype);
            branch->SetParentClass(clParent);
            fBranches.Add(branch);
         }
      }
   }

   return 1;
}

//______________________________________________________________________________
void TBranchElement::UpdateFile()
{
   // Refresh the value of fDirectory (i.e. where this branch writes/reads its buffers)
   // with the current value of fTree->GetCurrentFile unless this branch has been
   // redirected to a different file.  Also update the sub-branches.

   // The BranchCount and BranchCount2 are part of higher level branches' list of
   // branches.
   // if (fBranchCount) fBranchCount->UpdateFile();
   // if (fBranchCount2) fBranchCount2->UpdateFile();
   TBranch::UpdateFile();
}
 TBranchElement.cxx:1
 TBranchElement.cxx:2
 TBranchElement.cxx:3
 TBranchElement.cxx:4
 TBranchElement.cxx:5
 TBranchElement.cxx:6
 TBranchElement.cxx:7
 TBranchElement.cxx:8
 TBranchElement.cxx:9
 TBranchElement.cxx:10
 TBranchElement.cxx:11
 TBranchElement.cxx:12
 TBranchElement.cxx:13
 TBranchElement.cxx:14
 TBranchElement.cxx:15
 TBranchElement.cxx:16
 TBranchElement.cxx:17
 TBranchElement.cxx:18
 TBranchElement.cxx:19
 TBranchElement.cxx:20
 TBranchElement.cxx:21
 TBranchElement.cxx:22
 TBranchElement.cxx:23
 TBranchElement.cxx:24
 TBranchElement.cxx:25
 TBranchElement.cxx:26
 TBranchElement.cxx:27
 TBranchElement.cxx:28
 TBranchElement.cxx:29
 TBranchElement.cxx:30
 TBranchElement.cxx:31
 TBranchElement.cxx:32
 TBranchElement.cxx:33
 TBranchElement.cxx:34
 TBranchElement.cxx:35
 TBranchElement.cxx:36
 TBranchElement.cxx:37
 TBranchElement.cxx:38
 TBranchElement.cxx:39
 TBranchElement.cxx:40
 TBranchElement.cxx:41
 TBranchElement.cxx:42
 TBranchElement.cxx:43
 TBranchElement.cxx:44
 TBranchElement.cxx:45
 TBranchElement.cxx:46
 TBranchElement.cxx:47
 TBranchElement.cxx:48
 TBranchElement.cxx:49
 TBranchElement.cxx:50
 TBranchElement.cxx:51
 TBranchElement.cxx:52
 TBranchElement.cxx:53
 TBranchElement.cxx:54
 TBranchElement.cxx:55
 TBranchElement.cxx:56
 TBranchElement.cxx:57
 TBranchElement.cxx:58
 TBranchElement.cxx:59
 TBranchElement.cxx:60
 TBranchElement.cxx:61
 TBranchElement.cxx:62
 TBranchElement.cxx:63
 TBranchElement.cxx:64
 TBranchElement.cxx:65
 TBranchElement.cxx:66
 TBranchElement.cxx:67
 TBranchElement.cxx:68
 TBranchElement.cxx:69
 TBranchElement.cxx:70
 TBranchElement.cxx:71
 TBranchElement.cxx:72
 TBranchElement.cxx:73
 TBranchElement.cxx:74
 TBranchElement.cxx:75
 TBranchElement.cxx:76
 TBranchElement.cxx:77
 TBranchElement.cxx:78
 TBranchElement.cxx:79
 TBranchElement.cxx:80
 TBranchElement.cxx:81
 TBranchElement.cxx:82
 TBranchElement.cxx:83
 TBranchElement.cxx:84
 TBranchElement.cxx:85
 TBranchElement.cxx:86
 TBranchElement.cxx:87
 TBranchElement.cxx:88
 TBranchElement.cxx:89
 TBranchElement.cxx:90
 TBranchElement.cxx:91
 TBranchElement.cxx:92
 TBranchElement.cxx:93
 TBranchElement.cxx:94
 TBranchElement.cxx:95
 TBranchElement.cxx:96
 TBranchElement.cxx:97
 TBranchElement.cxx:98
 TBranchElement.cxx:99
 TBranchElement.cxx:100
 TBranchElement.cxx:101
 TBranchElement.cxx:102
 TBranchElement.cxx:103
 TBranchElement.cxx:104
 TBranchElement.cxx:105
 TBranchElement.cxx:106
 TBranchElement.cxx:107
 TBranchElement.cxx:108
 TBranchElement.cxx:109
 TBranchElement.cxx:110
 TBranchElement.cxx:111
 TBranchElement.cxx:112
 TBranchElement.cxx:113
 TBranchElement.cxx:114
 TBranchElement.cxx:115
 TBranchElement.cxx:116
 TBranchElement.cxx:117
 TBranchElement.cxx:118
 TBranchElement.cxx:119
 TBranchElement.cxx:120
 TBranchElement.cxx:121
 TBranchElement.cxx:122
 TBranchElement.cxx:123
 TBranchElement.cxx:124
 TBranchElement.cxx:125
 TBranchElement.cxx:126
 TBranchElement.cxx:127
 TBranchElement.cxx:128
 TBranchElement.cxx:129
 TBranchElement.cxx:130
 TBranchElement.cxx:131
 TBranchElement.cxx:132
 TBranchElement.cxx:133
 TBranchElement.cxx:134
 TBranchElement.cxx:135
 TBranchElement.cxx:136
 TBranchElement.cxx:137
 TBranchElement.cxx:138
 TBranchElement.cxx:139
 TBranchElement.cxx:140
 TBranchElement.cxx:141
 TBranchElement.cxx:142
 TBranchElement.cxx:143
 TBranchElement.cxx:144
 TBranchElement.cxx:145
 TBranchElement.cxx:146
 TBranchElement.cxx:147
 TBranchElement.cxx:148
 TBranchElement.cxx:149
 TBranchElement.cxx:150
 TBranchElement.cxx:151
 TBranchElement.cxx:152
 TBranchElement.cxx:153
 TBranchElement.cxx:154
 TBranchElement.cxx:155
 TBranchElement.cxx:156
 TBranchElement.cxx:157
 TBranchElement.cxx:158
 TBranchElement.cxx:159
 TBranchElement.cxx:160
 TBranchElement.cxx:161
 TBranchElement.cxx:162
 TBranchElement.cxx:163
 TBranchElement.cxx:164
 TBranchElement.cxx:165
 TBranchElement.cxx:166
 TBranchElement.cxx:167
 TBranchElement.cxx:168
 TBranchElement.cxx:169
 TBranchElement.cxx:170
 TBranchElement.cxx:171
 TBranchElement.cxx:172
 TBranchElement.cxx:173
 TBranchElement.cxx:174
 TBranchElement.cxx:175
 TBranchElement.cxx:176
 TBranchElement.cxx:177
 TBranchElement.cxx:178
 TBranchElement.cxx:179
 TBranchElement.cxx:180
 TBranchElement.cxx:181
 TBranchElement.cxx:182
 TBranchElement.cxx:183
 TBranchElement.cxx:184
 TBranchElement.cxx:185
 TBranchElement.cxx:186
 TBranchElement.cxx:187
 TBranchElement.cxx:188
 TBranchElement.cxx:189
 TBranchElement.cxx:190
 TBranchElement.cxx:191
 TBranchElement.cxx:192
 TBranchElement.cxx:193
 TBranchElement.cxx:194
 TBranchElement.cxx:195
 TBranchElement.cxx:196
 TBranchElement.cxx:197
 TBranchElement.cxx:198
 TBranchElement.cxx:199
 TBranchElement.cxx:200
 TBranchElement.cxx:201
 TBranchElement.cxx:202
 TBranchElement.cxx:203
 TBranchElement.cxx:204
 TBranchElement.cxx:205
 TBranchElement.cxx:206
 TBranchElement.cxx:207
 TBranchElement.cxx:208
 TBranchElement.cxx:209
 TBranchElement.cxx:210
 TBranchElement.cxx:211
 TBranchElement.cxx:212
 TBranchElement.cxx:213
 TBranchElement.cxx:214
 TBranchElement.cxx:215
 TBranchElement.cxx:216
 TBranchElement.cxx:217
 TBranchElement.cxx:218
 TBranchElement.cxx:219
 TBranchElement.cxx:220
 TBranchElement.cxx:221
 TBranchElement.cxx:222
 TBranchElement.cxx:223
 TBranchElement.cxx:224
 TBranchElement.cxx:225
 TBranchElement.cxx:226
 TBranchElement.cxx:227
 TBranchElement.cxx:228
 TBranchElement.cxx:229
 TBranchElement.cxx:230
 TBranchElement.cxx:231
 TBranchElement.cxx:232
 TBranchElement.cxx:233
 TBranchElement.cxx:234
 TBranchElement.cxx:235
 TBranchElement.cxx:236
 TBranchElement.cxx:237
 TBranchElement.cxx:238
 TBranchElement.cxx:239
 TBranchElement.cxx:240
 TBranchElement.cxx:241
 TBranchElement.cxx:242
 TBranchElement.cxx:243
 TBranchElement.cxx:244
 TBranchElement.cxx:245
 TBranchElement.cxx:246
 TBranchElement.cxx:247
 TBranchElement.cxx:248
 TBranchElement.cxx:249
 TBranchElement.cxx:250
 TBranchElement.cxx:251
 TBranchElement.cxx:252
 TBranchElement.cxx:253
 TBranchElement.cxx:254
 TBranchElement.cxx:255
 TBranchElement.cxx:256
 TBranchElement.cxx:257
 TBranchElement.cxx:258
 TBranchElement.cxx:259
 TBranchElement.cxx:260
 TBranchElement.cxx:261
 TBranchElement.cxx:262
 TBranchElement.cxx:263
 TBranchElement.cxx:264
 TBranchElement.cxx:265
 TBranchElement.cxx:266
 TBranchElement.cxx:267
 TBranchElement.cxx:268
 TBranchElement.cxx:269
 TBranchElement.cxx:270
 TBranchElement.cxx:271
 TBranchElement.cxx:272
 TBranchElement.cxx:273
 TBranchElement.cxx:274
 TBranchElement.cxx:275
 TBranchElement.cxx:276
 TBranchElement.cxx:277
 TBranchElement.cxx:278
 TBranchElement.cxx:279
 TBranchElement.cxx:280
 TBranchElement.cxx:281
 TBranchElement.cxx:282
 TBranchElement.cxx:283
 TBranchElement.cxx:284
 TBranchElement.cxx:285
 TBranchElement.cxx:286
 TBranchElement.cxx:287
 TBranchElement.cxx:288
 TBranchElement.cxx:289
 TBranchElement.cxx:290
 TBranchElement.cxx:291
 TBranchElement.cxx:292
 TBranchElement.cxx:293
 TBranchElement.cxx:294
 TBranchElement.cxx:295
 TBranchElement.cxx:296
 TBranchElement.cxx:297
 TBranchElement.cxx:298
 TBranchElement.cxx:299
 TBranchElement.cxx:300
 TBranchElement.cxx:301
 TBranchElement.cxx:302
 TBranchElement.cxx:303
 TBranchElement.cxx:304
 TBranchElement.cxx:305
 TBranchElement.cxx:306
 TBranchElement.cxx:307
 TBranchElement.cxx:308
 TBranchElement.cxx:309
 TBranchElement.cxx:310
 TBranchElement.cxx:311
 TBranchElement.cxx:312
 TBranchElement.cxx:313
 TBranchElement.cxx:314
 TBranchElement.cxx:315
 TBranchElement.cxx:316
 TBranchElement.cxx:317
 TBranchElement.cxx:318
 TBranchElement.cxx:319
 TBranchElement.cxx:320
 TBranchElement.cxx:321
 TBranchElement.cxx:322
 TBranchElement.cxx:323
 TBranchElement.cxx:324
 TBranchElement.cxx:325
 TBranchElement.cxx:326
 TBranchElement.cxx:327
 TBranchElement.cxx:328
 TBranchElement.cxx:329
 TBranchElement.cxx:330
 TBranchElement.cxx:331
 TBranchElement.cxx:332
 TBranchElement.cxx:333
 TBranchElement.cxx:334
 TBranchElement.cxx:335
 TBranchElement.cxx:336
 TBranchElement.cxx:337
 TBranchElement.cxx:338
 TBranchElement.cxx:339
 TBranchElement.cxx:340
 TBranchElement.cxx:341
 TBranchElement.cxx:342
 TBranchElement.cxx:343
 TBranchElement.cxx:344
 TBranchElement.cxx:345
 TBranchElement.cxx:346
 TBranchElement.cxx:347
 TBranchElement.cxx:348
 TBranchElement.cxx:349
 TBranchElement.cxx:350
 TBranchElement.cxx:351
 TBranchElement.cxx:352
 TBranchElement.cxx:353
 TBranchElement.cxx:354
 TBranchElement.cxx:355
 TBranchElement.cxx:356
 TBranchElement.cxx:357
 TBranchElement.cxx:358
 TBranchElement.cxx:359
 TBranchElement.cxx:360
 TBranchElement.cxx:361
 TBranchElement.cxx:362
 TBranchElement.cxx:363
 TBranchElement.cxx:364
 TBranchElement.cxx:365
 TBranchElement.cxx:366
 TBranchElement.cxx:367
 TBranchElement.cxx:368
 TBranchElement.cxx:369
 TBranchElement.cxx:370
 TBranchElement.cxx:371
 TBranchElement.cxx:372
 TBranchElement.cxx:373
 TBranchElement.cxx:374
 TBranchElement.cxx:375
 TBranchElement.cxx:376
 TBranchElement.cxx:377
 TBranchElement.cxx:378
 TBranchElement.cxx:379
 TBranchElement.cxx:380
 TBranchElement.cxx:381
 TBranchElement.cxx:382
 TBranchElement.cxx:383
 TBranchElement.cxx:384
 TBranchElement.cxx:385
 TBranchElement.cxx:386
 TBranchElement.cxx:387
 TBranchElement.cxx:388
 TBranchElement.cxx:389
 TBranchElement.cxx:390
 TBranchElement.cxx:391
 TBranchElement.cxx:392
 TBranchElement.cxx:393
 TBranchElement.cxx:394
 TBranchElement.cxx:395
 TBranchElement.cxx:396
 TBranchElement.cxx:397
 TBranchElement.cxx:398
 TBranchElement.cxx:399
 TBranchElement.cxx:400
 TBranchElement.cxx:401
 TBranchElement.cxx:402
 TBranchElement.cxx:403
 TBranchElement.cxx:404
 TBranchElement.cxx:405
 TBranchElement.cxx:406
 TBranchElement.cxx:407
 TBranchElement.cxx:408
 TBranchElement.cxx:409
 TBranchElement.cxx:410
 TBranchElement.cxx:411
 TBranchElement.cxx:412
 TBranchElement.cxx:413
 TBranchElement.cxx:414
 TBranchElement.cxx:415
 TBranchElement.cxx:416
 TBranchElement.cxx:417
 TBranchElement.cxx:418
 TBranchElement.cxx:419
 TBranchElement.cxx:420
 TBranchElement.cxx:421
 TBranchElement.cxx:422
 TBranchElement.cxx:423
 TBranchElement.cxx:424
 TBranchElement.cxx:425
 TBranchElement.cxx:426
 TBranchElement.cxx:427
 TBranchElement.cxx:428
 TBranchElement.cxx:429
 TBranchElement.cxx:430
 TBranchElement.cxx:431
 TBranchElement.cxx:432
 TBranchElement.cxx:433
 TBranchElement.cxx:434
 TBranchElement.cxx:435
 TBranchElement.cxx:436
 TBranchElement.cxx:437
 TBranchElement.cxx:438
 TBranchElement.cxx:439
 TBranchElement.cxx:440
 TBranchElement.cxx:441
 TBranchElement.cxx:442
 TBranchElement.cxx:443
 TBranchElement.cxx:444
 TBranchElement.cxx:445
 TBranchElement.cxx:446
 TBranchElement.cxx:447
 TBranchElement.cxx:448
 TBranchElement.cxx:449
 TBranchElement.cxx:450
 TBranchElement.cxx:451
 TBranchElement.cxx:452
 TBranchElement.cxx:453
 TBranchElement.cxx:454
 TBranchElement.cxx:455
 TBranchElement.cxx:456
 TBranchElement.cxx:457
 TBranchElement.cxx:458
 TBranchElement.cxx:459
 TBranchElement.cxx:460
 TBranchElement.cxx:461
 TBranchElement.cxx:462
 TBranchElement.cxx:463
 TBranchElement.cxx:464
 TBranchElement.cxx:465
 TBranchElement.cxx:466
 TBranchElement.cxx:467
 TBranchElement.cxx:468
 TBranchElement.cxx:469
 TBranchElement.cxx:470
 TBranchElement.cxx:471
 TBranchElement.cxx:472
 TBranchElement.cxx:473
 TBranchElement.cxx:474
 TBranchElement.cxx:475
 TBranchElement.cxx:476
 TBranchElement.cxx:477
 TBranchElement.cxx:478
 TBranchElement.cxx:479
 TBranchElement.cxx:480
 TBranchElement.cxx:481
 TBranchElement.cxx:482
 TBranchElement.cxx:483
 TBranchElement.cxx:484
 TBranchElement.cxx:485
 TBranchElement.cxx:486
 TBranchElement.cxx:487
 TBranchElement.cxx:488
 TBranchElement.cxx:489
 TBranchElement.cxx:490
 TBranchElement.cxx:491
 TBranchElement.cxx:492
 TBranchElement.cxx:493
 TBranchElement.cxx:494
 TBranchElement.cxx:495
 TBranchElement.cxx:496
 TBranchElement.cxx:497
 TBranchElement.cxx:498
 TBranchElement.cxx:499
 TBranchElement.cxx:500
 TBranchElement.cxx:501
 TBranchElement.cxx:502
 TBranchElement.cxx:503
 TBranchElement.cxx:504
 TBranchElement.cxx:505
 TBranchElement.cxx:506
 TBranchElement.cxx:507
 TBranchElement.cxx:508
 TBranchElement.cxx:509
 TBranchElement.cxx:510
 TBranchElement.cxx:511
 TBranchElement.cxx:512
 TBranchElement.cxx:513
 TBranchElement.cxx:514
 TBranchElement.cxx:515
 TBranchElement.cxx:516
 TBranchElement.cxx:517
 TBranchElement.cxx:518
 TBranchElement.cxx:519
 TBranchElement.cxx:520
 TBranchElement.cxx:521
 TBranchElement.cxx:522
 TBranchElement.cxx:523
 TBranchElement.cxx:524
 TBranchElement.cxx:525
 TBranchElement.cxx:526
 TBranchElement.cxx:527
 TBranchElement.cxx:528
 TBranchElement.cxx:529
 TBranchElement.cxx:530
 TBranchElement.cxx:531
 TBranchElement.cxx:532
 TBranchElement.cxx:533
 TBranchElement.cxx:534
 TBranchElement.cxx:535
 TBranchElement.cxx:536
 TBranchElement.cxx:537
 TBranchElement.cxx:538
 TBranchElement.cxx:539
 TBranchElement.cxx:540
 TBranchElement.cxx:541
 TBranchElement.cxx:542
 TBranchElement.cxx:543
 TBranchElement.cxx:544
 TBranchElement.cxx:545
 TBranchElement.cxx:546
 TBranchElement.cxx:547
 TBranchElement.cxx:548
 TBranchElement.cxx:549
 TBranchElement.cxx:550
 TBranchElement.cxx:551
 TBranchElement.cxx:552
 TBranchElement.cxx:553
 TBranchElement.cxx:554
 TBranchElement.cxx:555
 TBranchElement.cxx:556
 TBranchElement.cxx:557
 TBranchElement.cxx:558
 TBranchElement.cxx:559
 TBranchElement.cxx:560
 TBranchElement.cxx:561
 TBranchElement.cxx:562
 TBranchElement.cxx:563
 TBranchElement.cxx:564
 TBranchElement.cxx:565
 TBranchElement.cxx:566
 TBranchElement.cxx:567
 TBranchElement.cxx:568
 TBranchElement.cxx:569
 TBranchElement.cxx:570
 TBranchElement.cxx:571
 TBranchElement.cxx:572
 TBranchElement.cxx:573
 TBranchElement.cxx:574
 TBranchElement.cxx:575
 TBranchElement.cxx:576
 TBranchElement.cxx:577
 TBranchElement.cxx:578
 TBranchElement.cxx:579
 TBranchElement.cxx:580
 TBranchElement.cxx:581
 TBranchElement.cxx:582
 TBranchElement.cxx:583
 TBranchElement.cxx:584
 TBranchElement.cxx:585
 TBranchElement.cxx:586
 TBranchElement.cxx:587
 TBranchElement.cxx:588
 TBranchElement.cxx:589
 TBranchElement.cxx:590
 TBranchElement.cxx:591
 TBranchElement.cxx:592
 TBranchElement.cxx:593
 TBranchElement.cxx:594
 TBranchElement.cxx:595
 TBranchElement.cxx:596
 TBranchElement.cxx:597
 TBranchElement.cxx:598
 TBranchElement.cxx:599
 TBranchElement.cxx:600
 TBranchElement.cxx:601
 TBranchElement.cxx:602
 TBranchElement.cxx:603
 TBranchElement.cxx:604
 TBranchElement.cxx:605
 TBranchElement.cxx:606
 TBranchElement.cxx:607
 TBranchElement.cxx:608
 TBranchElement.cxx:609
 TBranchElement.cxx:610
 TBranchElement.cxx:611
 TBranchElement.cxx:612
 TBranchElement.cxx:613
 TBranchElement.cxx:614
 TBranchElement.cxx:615
 TBranchElement.cxx:616
 TBranchElement.cxx:617
 TBranchElement.cxx:618
 TBranchElement.cxx:619
 TBranchElement.cxx:620
 TBranchElement.cxx:621
 TBranchElement.cxx:622
 TBranchElement.cxx:623
 TBranchElement.cxx:624
 TBranchElement.cxx:625
 TBranchElement.cxx:626
 TBranchElement.cxx:627
 TBranchElement.cxx:628
 TBranchElement.cxx:629
 TBranchElement.cxx:630
 TBranchElement.cxx:631
 TBranchElement.cxx:632
 TBranchElement.cxx:633
 TBranchElement.cxx:634
 TBranchElement.cxx:635
 TBranchElement.cxx:636
 TBranchElement.cxx:637
 TBranchElement.cxx:638
 TBranchElement.cxx:639
 TBranchElement.cxx:640
 TBranchElement.cxx:641
 TBranchElement.cxx:642
 TBranchElement.cxx:643
 TBranchElement.cxx:644
 TBranchElement.cxx:645
 TBranchElement.cxx:646
 TBranchElement.cxx:647
 TBranchElement.cxx:648
 TBranchElement.cxx:649
 TBranchElement.cxx:650
 TBranchElement.cxx:651
 TBranchElement.cxx:652
 TBranchElement.cxx:653
 TBranchElement.cxx:654
 TBranchElement.cxx:655
 TBranchElement.cxx:656
 TBranchElement.cxx:657
 TBranchElement.cxx:658
 TBranchElement.cxx:659
 TBranchElement.cxx:660
 TBranchElement.cxx:661
 TBranchElement.cxx:662
 TBranchElement.cxx:663
 TBranchElement.cxx:664
 TBranchElement.cxx:665
 TBranchElement.cxx:666
 TBranchElement.cxx:667
 TBranchElement.cxx:668
 TBranchElement.cxx:669
 TBranchElement.cxx:670
 TBranchElement.cxx:671
 TBranchElement.cxx:672
 TBranchElement.cxx:673
 TBranchElement.cxx:674
 TBranchElement.cxx:675
 TBranchElement.cxx:676
 TBranchElement.cxx:677
 TBranchElement.cxx:678
 TBranchElement.cxx:679
 TBranchElement.cxx:680
 TBranchElement.cxx:681
 TBranchElement.cxx:682
 TBranchElement.cxx:683
 TBranchElement.cxx:684
 TBranchElement.cxx:685
 TBranchElement.cxx:686
 TBranchElement.cxx:687
 TBranchElement.cxx:688
 TBranchElement.cxx:689
 TBranchElement.cxx:690
 TBranchElement.cxx:691
 TBranchElement.cxx:692
 TBranchElement.cxx:693
 TBranchElement.cxx:694
 TBranchElement.cxx:695
 TBranchElement.cxx:696
 TBranchElement.cxx:697
 TBranchElement.cxx:698
 TBranchElement.cxx:699
 TBranchElement.cxx:700
 TBranchElement.cxx:701
 TBranchElement.cxx:702
 TBranchElement.cxx:703
 TBranchElement.cxx:704
 TBranchElement.cxx:705
 TBranchElement.cxx:706
 TBranchElement.cxx:707
 TBranchElement.cxx:708
 TBranchElement.cxx:709
 TBranchElement.cxx:710
 TBranchElement.cxx:711
 TBranchElement.cxx:712
 TBranchElement.cxx:713
 TBranchElement.cxx:714
 TBranchElement.cxx:715
 TBranchElement.cxx:716
 TBranchElement.cxx:717
 TBranchElement.cxx:718
 TBranchElement.cxx:719
 TBranchElement.cxx:720
 TBranchElement.cxx:721
 TBranchElement.cxx:722
 TBranchElement.cxx:723
 TBranchElement.cxx:724
 TBranchElement.cxx:725
 TBranchElement.cxx:726
 TBranchElement.cxx:727
 TBranchElement.cxx:728
 TBranchElement.cxx:729
 TBranchElement.cxx:730
 TBranchElement.cxx:731
 TBranchElement.cxx:732
 TBranchElement.cxx:733
 TBranchElement.cxx:734
 TBranchElement.cxx:735
 TBranchElement.cxx:736
 TBranchElement.cxx:737
 TBranchElement.cxx:738
 TBranchElement.cxx:739
 TBranchElement.cxx:740
 TBranchElement.cxx:741
 TBranchElement.cxx:742
 TBranchElement.cxx:743
 TBranchElement.cxx:744
 TBranchElement.cxx:745
 TBranchElement.cxx:746
 TBranchElement.cxx:747
 TBranchElement.cxx:748
 TBranchElement.cxx:749
 TBranchElement.cxx:750
 TBranchElement.cxx:751
 TBranchElement.cxx:752
 TBranchElement.cxx:753
 TBranchElement.cxx:754
 TBranchElement.cxx:755
 TBranchElement.cxx:756
 TBranchElement.cxx:757
 TBranchElement.cxx:758
 TBranchElement.cxx:759
 TBranchElement.cxx:760
 TBranchElement.cxx:761
 TBranchElement.cxx:762
 TBranchElement.cxx:763
 TBranchElement.cxx:764
 TBranchElement.cxx:765
 TBranchElement.cxx:766
 TBranchElement.cxx:767
 TBranchElement.cxx:768
 TBranchElement.cxx:769
 TBranchElement.cxx:770
 TBranchElement.cxx:771
 TBranchElement.cxx:772
 TBranchElement.cxx:773
 TBranchElement.cxx:774
 TBranchElement.cxx:775
 TBranchElement.cxx:776
 TBranchElement.cxx:777
 TBranchElement.cxx:778
 TBranchElement.cxx:779
 TBranchElement.cxx:780
 TBranchElement.cxx:781
 TBranchElement.cxx:782
 TBranchElement.cxx:783
 TBranchElement.cxx:784
 TBranchElement.cxx:785
 TBranchElement.cxx:786
 TBranchElement.cxx:787
 TBranchElement.cxx:788
 TBranchElement.cxx:789
 TBranchElement.cxx:790
 TBranchElement.cxx:791
 TBranchElement.cxx:792
 TBranchElement.cxx:793
 TBranchElement.cxx:794
 TBranchElement.cxx:795
 TBranchElement.cxx:796
 TBranchElement.cxx:797
 TBranchElement.cxx:798
 TBranchElement.cxx:799
 TBranchElement.cxx:800
 TBranchElement.cxx:801
 TBranchElement.cxx:802
 TBranchElement.cxx:803
 TBranchElement.cxx:804
 TBranchElement.cxx:805
 TBranchElement.cxx:806
 TBranchElement.cxx:807
 TBranchElement.cxx:808
 TBranchElement.cxx:809
 TBranchElement.cxx:810
 TBranchElement.cxx:811
 TBranchElement.cxx:812
 TBranchElement.cxx:813
 TBranchElement.cxx:814
 TBranchElement.cxx:815
 TBranchElement.cxx:816
 TBranchElement.cxx:817
 TBranchElement.cxx:818
 TBranchElement.cxx:819
 TBranchElement.cxx:820
 TBranchElement.cxx:821
 TBranchElement.cxx:822
 TBranchElement.cxx:823
 TBranchElement.cxx:824
 TBranchElement.cxx:825
 TBranchElement.cxx:826
 TBranchElement.cxx:827
 TBranchElement.cxx:828
 TBranchElement.cxx:829
 TBranchElement.cxx:830
 TBranchElement.cxx:831
 TBranchElement.cxx:832
 TBranchElement.cxx:833
 TBranchElement.cxx:834
 TBranchElement.cxx:835
 TBranchElement.cxx:836
 TBranchElement.cxx:837
 TBranchElement.cxx:838
 TBranchElement.cxx:839
 TBranchElement.cxx:840
 TBranchElement.cxx:841
 TBranchElement.cxx:842
 TBranchElement.cxx:843
 TBranchElement.cxx:844
 TBranchElement.cxx:845
 TBranchElement.cxx:846
 TBranchElement.cxx:847
 TBranchElement.cxx:848
 TBranchElement.cxx:849
 TBranchElement.cxx:850
 TBranchElement.cxx:851
 TBranchElement.cxx:852
 TBranchElement.cxx:853
 TBranchElement.cxx:854
 TBranchElement.cxx:855
 TBranchElement.cxx:856
 TBranchElement.cxx:857
 TBranchElement.cxx:858
 TBranchElement.cxx:859
 TBranchElement.cxx:860
 TBranchElement.cxx:861
 TBranchElement.cxx:862
 TBranchElement.cxx:863
 TBranchElement.cxx:864
 TBranchElement.cxx:865
 TBranchElement.cxx:866
 TBranchElement.cxx:867
 TBranchElement.cxx:868
 TBranchElement.cxx:869
 TBranchElement.cxx:870
 TBranchElement.cxx:871
 TBranchElement.cxx:872
 TBranchElement.cxx:873
 TBranchElement.cxx:874
 TBranchElement.cxx:875
 TBranchElement.cxx:876
 TBranchElement.cxx:877
 TBranchElement.cxx:878
 TBranchElement.cxx:879
 TBranchElement.cxx:880
 TBranchElement.cxx:881
 TBranchElement.cxx:882
 TBranchElement.cxx:883
 TBranchElement.cxx:884
 TBranchElement.cxx:885
 TBranchElement.cxx:886
 TBranchElement.cxx:887
 TBranchElement.cxx:888
 TBranchElement.cxx:889
 TBranchElement.cxx:890
 TBranchElement.cxx:891
 TBranchElement.cxx:892
 TBranchElement.cxx:893
 TBranchElement.cxx:894
 TBranchElement.cxx:895
 TBranchElement.cxx:896
 TBranchElement.cxx:897
 TBranchElement.cxx:898
 TBranchElement.cxx:899
 TBranchElement.cxx:900
 TBranchElement.cxx:901
 TBranchElement.cxx:902
 TBranchElement.cxx:903
 TBranchElement.cxx:904
 TBranchElement.cxx:905
 TBranchElement.cxx:906
 TBranchElement.cxx:907
 TBranchElement.cxx:908
 TBranchElement.cxx:909
 TBranchElement.cxx:910
 TBranchElement.cxx:911
 TBranchElement.cxx:912
 TBranchElement.cxx:913
 TBranchElement.cxx:914
 TBranchElement.cxx:915
 TBranchElement.cxx:916
 TBranchElement.cxx:917
 TBranchElement.cxx:918
 TBranchElement.cxx:919
 TBranchElement.cxx:920
 TBranchElement.cxx:921
 TBranchElement.cxx:922
 TBranchElement.cxx:923
 TBranchElement.cxx:924
 TBranchElement.cxx:925
 TBranchElement.cxx:926
 TBranchElement.cxx:927
 TBranchElement.cxx:928
 TBranchElement.cxx:929
 TBranchElement.cxx:930
 TBranchElement.cxx:931
 TBranchElement.cxx:932
 TBranchElement.cxx:933
 TBranchElement.cxx:934
 TBranchElement.cxx:935
 TBranchElement.cxx:936
 TBranchElement.cxx:937
 TBranchElement.cxx:938
 TBranchElement.cxx:939
 TBranchElement.cxx:940
 TBranchElement.cxx:941
 TBranchElement.cxx:942
 TBranchElement.cxx:943
 TBranchElement.cxx:944
 TBranchElement.cxx:945
 TBranchElement.cxx:946
 TBranchElement.cxx:947
 TBranchElement.cxx:948
 TBranchElement.cxx:949
 TBranchElement.cxx:950
 TBranchElement.cxx:951
 TBranchElement.cxx:952
 TBranchElement.cxx:953
 TBranchElement.cxx:954
 TBranchElement.cxx:955
 TBranchElement.cxx:956
 TBranchElement.cxx:957
 TBranchElement.cxx:958
 TBranchElement.cxx:959
 TBranchElement.cxx:960
 TBranchElement.cxx:961
 TBranchElement.cxx:962
 TBranchElement.cxx:963
 TBranchElement.cxx:964
 TBranchElement.cxx:965
 TBranchElement.cxx:966
 TBranchElement.cxx:967
 TBranchElement.cxx:968
 TBranchElement.cxx:969
 TBranchElement.cxx:970
 TBranchElement.cxx:971
 TBranchElement.cxx:972
 TBranchElement.cxx:973
 TBranchElement.cxx:974
 TBranchElement.cxx:975
 TBranchElement.cxx:976
 TBranchElement.cxx:977
 TBranchElement.cxx:978
 TBranchElement.cxx:979
 TBranchElement.cxx:980
 TBranchElement.cxx:981
 TBranchElement.cxx:982
 TBranchElement.cxx:983
 TBranchElement.cxx:984
 TBranchElement.cxx:985
 TBranchElement.cxx:986
 TBranchElement.cxx:987
 TBranchElement.cxx:988
 TBranchElement.cxx:989
 TBranchElement.cxx:990
 TBranchElement.cxx:991
 TBranchElement.cxx:992
 TBranchElement.cxx:993
 TBranchElement.cxx:994
 TBranchElement.cxx:995
 TBranchElement.cxx:996
 TBranchElement.cxx:997
 TBranchElement.cxx:998
 TBranchElement.cxx:999
 TBranchElement.cxx:1000
 TBranchElement.cxx:1001
 TBranchElement.cxx:1002
 TBranchElement.cxx:1003
 TBranchElement.cxx:1004
 TBranchElement.cxx:1005
 TBranchElement.cxx:1006
 TBranchElement.cxx:1007
 TBranchElement.cxx:1008
 TBranchElement.cxx:1009
 TBranchElement.cxx:1010
 TBranchElement.cxx:1011
 TBranchElement.cxx:1012
 TBranchElement.cxx:1013
 TBranchElement.cxx:1014
 TBranchElement.cxx:1015
 TBranchElement.cxx:1016
 TBranchElement.cxx:1017
 TBranchElement.cxx:1018
 TBranchElement.cxx:1019
 TBranchElement.cxx:1020
 TBranchElement.cxx:1021
 TBranchElement.cxx:1022
 TBranchElement.cxx:1023
 TBranchElement.cxx:1024
 TBranchElement.cxx:1025
 TBranchElement.cxx:1026
 TBranchElement.cxx:1027
 TBranchElement.cxx:1028
 TBranchElement.cxx:1029
 TBranchElement.cxx:1030
 TBranchElement.cxx:1031
 TBranchElement.cxx:1032
 TBranchElement.cxx:1033
 TBranchElement.cxx:1034
 TBranchElement.cxx:1035
 TBranchElement.cxx:1036
 TBranchElement.cxx:1037
 TBranchElement.cxx:1038
 TBranchElement.cxx:1039
 TBranchElement.cxx:1040
 TBranchElement.cxx:1041
 TBranchElement.cxx:1042
 TBranchElement.cxx:1043
 TBranchElement.cxx:1044
 TBranchElement.cxx:1045
 TBranchElement.cxx:1046
 TBranchElement.cxx:1047
 TBranchElement.cxx:1048
 TBranchElement.cxx:1049
 TBranchElement.cxx:1050
 TBranchElement.cxx:1051
 TBranchElement.cxx:1052
 TBranchElement.cxx:1053
 TBranchElement.cxx:1054
 TBranchElement.cxx:1055
 TBranchElement.cxx:1056
 TBranchElement.cxx:1057
 TBranchElement.cxx:1058
 TBranchElement.cxx:1059
 TBranchElement.cxx:1060
 TBranchElement.cxx:1061
 TBranchElement.cxx:1062
 TBranchElement.cxx:1063
 TBranchElement.cxx:1064
 TBranchElement.cxx:1065
 TBranchElement.cxx:1066
 TBranchElement.cxx:1067
 TBranchElement.cxx:1068
 TBranchElement.cxx:1069
 TBranchElement.cxx:1070
 TBranchElement.cxx:1071
 TBranchElement.cxx:1072
 TBranchElement.cxx:1073
 TBranchElement.cxx:1074
 TBranchElement.cxx:1075
 TBranchElement.cxx:1076
 TBranchElement.cxx:1077
 TBranchElement.cxx:1078
 TBranchElement.cxx:1079
 TBranchElement.cxx:1080
 TBranchElement.cxx:1081
 TBranchElement.cxx:1082
 TBranchElement.cxx:1083
 TBranchElement.cxx:1084
 TBranchElement.cxx:1085
 TBranchElement.cxx:1086
 TBranchElement.cxx:1087
 TBranchElement.cxx:1088
 TBranchElement.cxx:1089
 TBranchElement.cxx:1090
 TBranchElement.cxx:1091
 TBranchElement.cxx:1092
 TBranchElement.cxx:1093
 TBranchElement.cxx:1094
 TBranchElement.cxx:1095
 TBranchElement.cxx:1096
 TBranchElement.cxx:1097
 TBranchElement.cxx:1098
 TBranchElement.cxx:1099
 TBranchElement.cxx:1100
 TBranchElement.cxx:1101
 TBranchElement.cxx:1102
 TBranchElement.cxx:1103
 TBranchElement.cxx:1104
 TBranchElement.cxx:1105
 TBranchElement.cxx:1106
 TBranchElement.cxx:1107
 TBranchElement.cxx:1108
 TBranchElement.cxx:1109
 TBranchElement.cxx:1110
 TBranchElement.cxx:1111
 TBranchElement.cxx:1112
 TBranchElement.cxx:1113
 TBranchElement.cxx:1114
 TBranchElement.cxx:1115
 TBranchElement.cxx:1116
 TBranchElement.cxx:1117
 TBranchElement.cxx:1118
 TBranchElement.cxx:1119
 TBranchElement.cxx:1120
 TBranchElement.cxx:1121
 TBranchElement.cxx:1122
 TBranchElement.cxx:1123
 TBranchElement.cxx:1124
 TBranchElement.cxx:1125
 TBranchElement.cxx:1126
 TBranchElement.cxx:1127
 TBranchElement.cxx:1128
 TBranchElement.cxx:1129
 TBranchElement.cxx:1130
 TBranchElement.cxx:1131
 TBranchElement.cxx:1132
 TBranchElement.cxx:1133
 TBranchElement.cxx:1134
 TBranchElement.cxx:1135
 TBranchElement.cxx:1136
 TBranchElement.cxx:1137
 TBranchElement.cxx:1138
 TBranchElement.cxx:1139
 TBranchElement.cxx:1140
 TBranchElement.cxx:1141
 TBranchElement.cxx:1142
 TBranchElement.cxx:1143
 TBranchElement.cxx:1144
 TBranchElement.cxx:1145
 TBranchElement.cxx:1146
 TBranchElement.cxx:1147
 TBranchElement.cxx:1148
 TBranchElement.cxx:1149
 TBranchElement.cxx:1150
 TBranchElement.cxx:1151
 TBranchElement.cxx:1152
 TBranchElement.cxx:1153
 TBranchElement.cxx:1154
 TBranchElement.cxx:1155
 TBranchElement.cxx:1156
 TBranchElement.cxx:1157
 TBranchElement.cxx:1158
 TBranchElement.cxx:1159
 TBranchElement.cxx:1160
 TBranchElement.cxx:1161
 TBranchElement.cxx:1162
 TBranchElement.cxx:1163
 TBranchElement.cxx:1164
 TBranchElement.cxx:1165
 TBranchElement.cxx:1166
 TBranchElement.cxx:1167
 TBranchElement.cxx:1168
 TBranchElement.cxx:1169
 TBranchElement.cxx:1170
 TBranchElement.cxx:1171
 TBranchElement.cxx:1172
 TBranchElement.cxx:1173
 TBranchElement.cxx:1174
 TBranchElement.cxx:1175
 TBranchElement.cxx:1176
 TBranchElement.cxx:1177
 TBranchElement.cxx:1178
 TBranchElement.cxx:1179
 TBranchElement.cxx:1180
 TBranchElement.cxx:1181
 TBranchElement.cxx:1182
 TBranchElement.cxx:1183
 TBranchElement.cxx:1184
 TBranchElement.cxx:1185
 TBranchElement.cxx:1186
 TBranchElement.cxx:1187
 TBranchElement.cxx:1188
 TBranchElement.cxx:1189
 TBranchElement.cxx:1190
 TBranchElement.cxx:1191
 TBranchElement.cxx:1192
 TBranchElement.cxx:1193
 TBranchElement.cxx:1194
 TBranchElement.cxx:1195
 TBranchElement.cxx:1196
 TBranchElement.cxx:1197
 TBranchElement.cxx:1198
 TBranchElement.cxx:1199
 TBranchElement.cxx:1200
 TBranchElement.cxx:1201
 TBranchElement.cxx:1202
 TBranchElement.cxx:1203
 TBranchElement.cxx:1204
 TBranchElement.cxx:1205
 TBranchElement.cxx:1206
 TBranchElement.cxx:1207
 TBranchElement.cxx:1208
 TBranchElement.cxx:1209
 TBranchElement.cxx:1210
 TBranchElement.cxx:1211
 TBranchElement.cxx:1212
 TBranchElement.cxx:1213
 TBranchElement.cxx:1214
 TBranchElement.cxx:1215
 TBranchElement.cxx:1216
 TBranchElement.cxx:1217
 TBranchElement.cxx:1218
 TBranchElement.cxx:1219
 TBranchElement.cxx:1220
 TBranchElement.cxx:1221
 TBranchElement.cxx:1222
 TBranchElement.cxx:1223
 TBranchElement.cxx:1224
 TBranchElement.cxx:1225
 TBranchElement.cxx:1226
 TBranchElement.cxx:1227
 TBranchElement.cxx:1228
 TBranchElement.cxx:1229
 TBranchElement.cxx:1230
 TBranchElement.cxx:1231
 TBranchElement.cxx:1232
 TBranchElement.cxx:1233
 TBranchElement.cxx:1234
 TBranchElement.cxx:1235
 TBranchElement.cxx:1236
 TBranchElement.cxx:1237
 TBranchElement.cxx:1238
 TBranchElement.cxx:1239
 TBranchElement.cxx:1240
 TBranchElement.cxx:1241
 TBranchElement.cxx:1242
 TBranchElement.cxx:1243
 TBranchElement.cxx:1244
 TBranchElement.cxx:1245
 TBranchElement.cxx:1246
 TBranchElement.cxx:1247
 TBranchElement.cxx:1248
 TBranchElement.cxx:1249
 TBranchElement.cxx:1250
 TBranchElement.cxx:1251
 TBranchElement.cxx:1252
 TBranchElement.cxx:1253
 TBranchElement.cxx:1254
 TBranchElement.cxx:1255
 TBranchElement.cxx:1256
 TBranchElement.cxx:1257
 TBranchElement.cxx:1258
 TBranchElement.cxx:1259
 TBranchElement.cxx:1260
 TBranchElement.cxx:1261
 TBranchElement.cxx:1262
 TBranchElement.cxx:1263
 TBranchElement.cxx:1264
 TBranchElement.cxx:1265
 TBranchElement.cxx:1266
 TBranchElement.cxx:1267
 TBranchElement.cxx:1268
 TBranchElement.cxx:1269
 TBranchElement.cxx:1270
 TBranchElement.cxx:1271
 TBranchElement.cxx:1272
 TBranchElement.cxx:1273
 TBranchElement.cxx:1274
 TBranchElement.cxx:1275
 TBranchElement.cxx:1276
 TBranchElement.cxx:1277
 TBranchElement.cxx:1278
 TBranchElement.cxx:1279
 TBranchElement.cxx:1280
 TBranchElement.cxx:1281
 TBranchElement.cxx:1282
 TBranchElement.cxx:1283
 TBranchElement.cxx:1284
 TBranchElement.cxx:1285
 TBranchElement.cxx:1286
 TBranchElement.cxx:1287
 TBranchElement.cxx:1288
 TBranchElement.cxx:1289
 TBranchElement.cxx:1290
 TBranchElement.cxx:1291
 TBranchElement.cxx:1292
 TBranchElement.cxx:1293
 TBranchElement.cxx:1294
 TBranchElement.cxx:1295
 TBranchElement.cxx:1296
 TBranchElement.cxx:1297
 TBranchElement.cxx:1298
 TBranchElement.cxx:1299
 TBranchElement.cxx:1300
 TBranchElement.cxx:1301
 TBranchElement.cxx:1302
 TBranchElement.cxx:1303
 TBranchElement.cxx:1304
 TBranchElement.cxx:1305
 TBranchElement.cxx:1306
 TBranchElement.cxx:1307
 TBranchElement.cxx:1308
 TBranchElement.cxx:1309
 TBranchElement.cxx:1310
 TBranchElement.cxx:1311
 TBranchElement.cxx:1312
 TBranchElement.cxx:1313
 TBranchElement.cxx:1314
 TBranchElement.cxx:1315
 TBranchElement.cxx:1316
 TBranchElement.cxx:1317
 TBranchElement.cxx:1318
 TBranchElement.cxx:1319
 TBranchElement.cxx:1320
 TBranchElement.cxx:1321
 TBranchElement.cxx:1322
 TBranchElement.cxx:1323
 TBranchElement.cxx:1324
 TBranchElement.cxx:1325
 TBranchElement.cxx:1326
 TBranchElement.cxx:1327
 TBranchElement.cxx:1328
 TBranchElement.cxx:1329
 TBranchElement.cxx:1330
 TBranchElement.cxx:1331
 TBranchElement.cxx:1332
 TBranchElement.cxx:1333
 TBranchElement.cxx:1334
 TBranchElement.cxx:1335
 TBranchElement.cxx:1336
 TBranchElement.cxx:1337
 TBranchElement.cxx:1338
 TBranchElement.cxx:1339
 TBranchElement.cxx:1340
 TBranchElement.cxx:1341
 TBranchElement.cxx:1342
 TBranchElement.cxx:1343
 TBranchElement.cxx:1344
 TBranchElement.cxx:1345
 TBranchElement.cxx:1346
 TBranchElement.cxx:1347
 TBranchElement.cxx:1348
 TBranchElement.cxx:1349
 TBranchElement.cxx:1350
 TBranchElement.cxx:1351
 TBranchElement.cxx:1352
 TBranchElement.cxx:1353
 TBranchElement.cxx:1354
 TBranchElement.cxx:1355
 TBranchElement.cxx:1356
 TBranchElement.cxx:1357
 TBranchElement.cxx:1358
 TBranchElement.cxx:1359
 TBranchElement.cxx:1360
 TBranchElement.cxx:1361
 TBranchElement.cxx:1362
 TBranchElement.cxx:1363
 TBranchElement.cxx:1364
 TBranchElement.cxx:1365
 TBranchElement.cxx:1366
 TBranchElement.cxx:1367
 TBranchElement.cxx:1368
 TBranchElement.cxx:1369
 TBranchElement.cxx:1370
 TBranchElement.cxx:1371
 TBranchElement.cxx:1372
 TBranchElement.cxx:1373
 TBranchElement.cxx:1374
 TBranchElement.cxx:1375
 TBranchElement.cxx:1376
 TBranchElement.cxx:1377
 TBranchElement.cxx:1378
 TBranchElement.cxx:1379
 TBranchElement.cxx:1380
 TBranchElement.cxx:1381
 TBranchElement.cxx:1382
 TBranchElement.cxx:1383
 TBranchElement.cxx:1384
 TBranchElement.cxx:1385
 TBranchElement.cxx:1386
 TBranchElement.cxx:1387
 TBranchElement.cxx:1388
 TBranchElement.cxx:1389
 TBranchElement.cxx:1390
 TBranchElement.cxx:1391
 TBranchElement.cxx:1392
 TBranchElement.cxx:1393
 TBranchElement.cxx:1394
 TBranchElement.cxx:1395
 TBranchElement.cxx:1396
 TBranchElement.cxx:1397
 TBranchElement.cxx:1398
 TBranchElement.cxx:1399
 TBranchElement.cxx:1400
 TBranchElement.cxx:1401
 TBranchElement.cxx:1402
 TBranchElement.cxx:1403
 TBranchElement.cxx:1404
 TBranchElement.cxx:1405
 TBranchElement.cxx:1406
 TBranchElement.cxx:1407
 TBranchElement.cxx:1408
 TBranchElement.cxx:1409
 TBranchElement.cxx:1410
 TBranchElement.cxx:1411
 TBranchElement.cxx:1412
 TBranchElement.cxx:1413
 TBranchElement.cxx:1414
 TBranchElement.cxx:1415
 TBranchElement.cxx:1416
 TBranchElement.cxx:1417
 TBranchElement.cxx:1418
 TBranchElement.cxx:1419
 TBranchElement.cxx:1420
 TBranchElement.cxx:1421
 TBranchElement.cxx:1422
 TBranchElement.cxx:1423
 TBranchElement.cxx:1424
 TBranchElement.cxx:1425
 TBranchElement.cxx:1426
 TBranchElement.cxx:1427
 TBranchElement.cxx:1428
 TBranchElement.cxx:1429
 TBranchElement.cxx:1430
 TBranchElement.cxx:1431
 TBranchElement.cxx:1432
 TBranchElement.cxx:1433
 TBranchElement.cxx:1434
 TBranchElement.cxx:1435
 TBranchElement.cxx:1436
 TBranchElement.cxx:1437
 TBranchElement.cxx:1438
 TBranchElement.cxx:1439
 TBranchElement.cxx:1440
 TBranchElement.cxx:1441
 TBranchElement.cxx:1442
 TBranchElement.cxx:1443
 TBranchElement.cxx:1444
 TBranchElement.cxx:1445
 TBranchElement.cxx:1446
 TBranchElement.cxx:1447
 TBranchElement.cxx:1448
 TBranchElement.cxx:1449
 TBranchElement.cxx:1450
 TBranchElement.cxx:1451
 TBranchElement.cxx:1452
 TBranchElement.cxx:1453
 TBranchElement.cxx:1454
 TBranchElement.cxx:1455
 TBranchElement.cxx:1456
 TBranchElement.cxx:1457
 TBranchElement.cxx:1458
 TBranchElement.cxx:1459
 TBranchElement.cxx:1460
 TBranchElement.cxx:1461
 TBranchElement.cxx:1462
 TBranchElement.cxx:1463
 TBranchElement.cxx:1464
 TBranchElement.cxx:1465
 TBranchElement.cxx:1466
 TBranchElement.cxx:1467
 TBranchElement.cxx:1468
 TBranchElement.cxx:1469
 TBranchElement.cxx:1470
 TBranchElement.cxx:1471
 TBranchElement.cxx:1472
 TBranchElement.cxx:1473
 TBranchElement.cxx:1474
 TBranchElement.cxx:1475
 TBranchElement.cxx:1476
 TBranchElement.cxx:1477
 TBranchElement.cxx:1478
 TBranchElement.cxx:1479
 TBranchElement.cxx:1480
 TBranchElement.cxx:1481
 TBranchElement.cxx:1482
 TBranchElement.cxx:1483
 TBranchElement.cxx:1484
 TBranchElement.cxx:1485
 TBranchElement.cxx:1486
 TBranchElement.cxx:1487
 TBranchElement.cxx:1488
 TBranchElement.cxx:1489
 TBranchElement.cxx:1490
 TBranchElement.cxx:1491
 TBranchElement.cxx:1492
 TBranchElement.cxx:1493
 TBranchElement.cxx:1494
 TBranchElement.cxx:1495
 TBranchElement.cxx:1496
 TBranchElement.cxx:1497
 TBranchElement.cxx:1498
 TBranchElement.cxx:1499
 TBranchElement.cxx:1500
 TBranchElement.cxx:1501
 TBranchElement.cxx:1502
 TBranchElement.cxx:1503
 TBranchElement.cxx:1504
 TBranchElement.cxx:1505
 TBranchElement.cxx:1506
 TBranchElement.cxx:1507
 TBranchElement.cxx:1508
 TBranchElement.cxx:1509
 TBranchElement.cxx:1510
 TBranchElement.cxx:1511
 TBranchElement.cxx:1512
 TBranchElement.cxx:1513
 TBranchElement.cxx:1514
 TBranchElement.cxx:1515
 TBranchElement.cxx:1516
 TBranchElement.cxx:1517
 TBranchElement.cxx:1518
 TBranchElement.cxx:1519
 TBranchElement.cxx:1520
 TBranchElement.cxx:1521
 TBranchElement.cxx:1522
 TBranchElement.cxx:1523
 TBranchElement.cxx:1524
 TBranchElement.cxx:1525
 TBranchElement.cxx:1526
 TBranchElement.cxx:1527
 TBranchElement.cxx:1528
 TBranchElement.cxx:1529
 TBranchElement.cxx:1530
 TBranchElement.cxx:1531
 TBranchElement.cxx:1532
 TBranchElement.cxx:1533
 TBranchElement.cxx:1534
 TBranchElement.cxx:1535
 TBranchElement.cxx:1536
 TBranchElement.cxx:1537
 TBranchElement.cxx:1538
 TBranchElement.cxx:1539
 TBranchElement.cxx:1540
 TBranchElement.cxx:1541
 TBranchElement.cxx:1542
 TBranchElement.cxx:1543
 TBranchElement.cxx:1544
 TBranchElement.cxx:1545
 TBranchElement.cxx:1546
 TBranchElement.cxx:1547
 TBranchElement.cxx:1548
 TBranchElement.cxx:1549
 TBranchElement.cxx:1550
 TBranchElement.cxx:1551
 TBranchElement.cxx:1552
 TBranchElement.cxx:1553
 TBranchElement.cxx:1554
 TBranchElement.cxx:1555
 TBranchElement.cxx:1556
 TBranchElement.cxx:1557
 TBranchElement.cxx:1558
 TBranchElement.cxx:1559
 TBranchElement.cxx:1560
 TBranchElement.cxx:1561
 TBranchElement.cxx:1562
 TBranchElement.cxx:1563
 TBranchElement.cxx:1564
 TBranchElement.cxx:1565
 TBranchElement.cxx:1566
 TBranchElement.cxx:1567
 TBranchElement.cxx:1568
 TBranchElement.cxx:1569
 TBranchElement.cxx:1570
 TBranchElement.cxx:1571
 TBranchElement.cxx:1572
 TBranchElement.cxx:1573
 TBranchElement.cxx:1574
 TBranchElement.cxx:1575
 TBranchElement.cxx:1576
 TBranchElement.cxx:1577
 TBranchElement.cxx:1578
 TBranchElement.cxx:1579
 TBranchElement.cxx:1580
 TBranchElement.cxx:1581
 TBranchElement.cxx:1582
 TBranchElement.cxx:1583
 TBranchElement.cxx:1584
 TBranchElement.cxx:1585
 TBranchElement.cxx:1586
 TBranchElement.cxx:1587
 TBranchElement.cxx:1588
 TBranchElement.cxx:1589
 TBranchElement.cxx:1590
 TBranchElement.cxx:1591
 TBranchElement.cxx:1592
 TBranchElement.cxx:1593
 TBranchElement.cxx:1594
 TBranchElement.cxx:1595
 TBranchElement.cxx:1596
 TBranchElement.cxx:1597
 TBranchElement.cxx:1598
 TBranchElement.cxx:1599
 TBranchElement.cxx:1600
 TBranchElement.cxx:1601
 TBranchElement.cxx:1602
 TBranchElement.cxx:1603
 TBranchElement.cxx:1604
 TBranchElement.cxx:1605
 TBranchElement.cxx:1606
 TBranchElement.cxx:1607
 TBranchElement.cxx:1608
 TBranchElement.cxx:1609
 TBranchElement.cxx:1610
 TBranchElement.cxx:1611
 TBranchElement.cxx:1612
 TBranchElement.cxx:1613
 TBranchElement.cxx:1614
 TBranchElement.cxx:1615
 TBranchElement.cxx:1616
 TBranchElement.cxx:1617
 TBranchElement.cxx:1618
 TBranchElement.cxx:1619
 TBranchElement.cxx:1620
 TBranchElement.cxx:1621
 TBranchElement.cxx:1622
 TBranchElement.cxx:1623
 TBranchElement.cxx:1624
 TBranchElement.cxx:1625
 TBranchElement.cxx:1626
 TBranchElement.cxx:1627
 TBranchElement.cxx:1628
 TBranchElement.cxx:1629
 TBranchElement.cxx:1630
 TBranchElement.cxx:1631
 TBranchElement.cxx:1632
 TBranchElement.cxx:1633
 TBranchElement.cxx:1634
 TBranchElement.cxx:1635
 TBranchElement.cxx:1636
 TBranchElement.cxx:1637
 TBranchElement.cxx:1638
 TBranchElement.cxx:1639
 TBranchElement.cxx:1640
 TBranchElement.cxx:1641
 TBranchElement.cxx:1642
 TBranchElement.cxx:1643
 TBranchElement.cxx:1644
 TBranchElement.cxx:1645
 TBranchElement.cxx:1646
 TBranchElement.cxx:1647
 TBranchElement.cxx:1648
 TBranchElement.cxx:1649
 TBranchElement.cxx:1650
 TBranchElement.cxx:1651
 TBranchElement.cxx:1652
 TBranchElement.cxx:1653
 TBranchElement.cxx:1654
 TBranchElement.cxx:1655
 TBranchElement.cxx:1656
 TBranchElement.cxx:1657
 TBranchElement.cxx:1658
 TBranchElement.cxx:1659
 TBranchElement.cxx:1660
 TBranchElement.cxx:1661
 TBranchElement.cxx:1662
 TBranchElement.cxx:1663
 TBranchElement.cxx:1664
 TBranchElement.cxx:1665
 TBranchElement.cxx:1666
 TBranchElement.cxx:1667
 TBranchElement.cxx:1668
 TBranchElement.cxx:1669
 TBranchElement.cxx:1670
 TBranchElement.cxx:1671
 TBranchElement.cxx:1672
 TBranchElement.cxx:1673
 TBranchElement.cxx:1674
 TBranchElement.cxx:1675
 TBranchElement.cxx:1676
 TBranchElement.cxx:1677
 TBranchElement.cxx:1678
 TBranchElement.cxx:1679
 TBranchElement.cxx:1680
 TBranchElement.cxx:1681
 TBranchElement.cxx:1682
 TBranchElement.cxx:1683
 TBranchElement.cxx:1684
 TBranchElement.cxx:1685
 TBranchElement.cxx:1686
 TBranchElement.cxx:1687
 TBranchElement.cxx:1688
 TBranchElement.cxx:1689
 TBranchElement.cxx:1690
 TBranchElement.cxx:1691
 TBranchElement.cxx:1692
 TBranchElement.cxx:1693
 TBranchElement.cxx:1694
 TBranchElement.cxx:1695
 TBranchElement.cxx:1696
 TBranchElement.cxx:1697
 TBranchElement.cxx:1698
 TBranchElement.cxx:1699
 TBranchElement.cxx:1700
 TBranchElement.cxx:1701
 TBranchElement.cxx:1702
 TBranchElement.cxx:1703
 TBranchElement.cxx:1704
 TBranchElement.cxx:1705
 TBranchElement.cxx:1706
 TBranchElement.cxx:1707
 TBranchElement.cxx:1708
 TBranchElement.cxx:1709
 TBranchElement.cxx:1710
 TBranchElement.cxx:1711
 TBranchElement.cxx:1712
 TBranchElement.cxx:1713
 TBranchElement.cxx:1714
 TBranchElement.cxx:1715
 TBranchElement.cxx:1716
 TBranchElement.cxx:1717
 TBranchElement.cxx:1718
 TBranchElement.cxx:1719
 TBranchElement.cxx:1720
 TBranchElement.cxx:1721
 TBranchElement.cxx:1722
 TBranchElement.cxx:1723
 TBranchElement.cxx:1724
 TBranchElement.cxx:1725
 TBranchElement.cxx:1726
 TBranchElement.cxx:1727
 TBranchElement.cxx:1728
 TBranchElement.cxx:1729
 TBranchElement.cxx:1730
 TBranchElement.cxx:1731
 TBranchElement.cxx:1732
 TBranchElement.cxx:1733
 TBranchElement.cxx:1734
 TBranchElement.cxx:1735
 TBranchElement.cxx:1736
 TBranchElement.cxx:1737
 TBranchElement.cxx:1738
 TBranchElement.cxx:1739
 TBranchElement.cxx:1740
 TBranchElement.cxx:1741
 TBranchElement.cxx:1742
 TBranchElement.cxx:1743
 TBranchElement.cxx:1744
 TBranchElement.cxx:1745
 TBranchElement.cxx:1746
 TBranchElement.cxx:1747
 TBranchElement.cxx:1748
 TBranchElement.cxx:1749
 TBranchElement.cxx:1750
 TBranchElement.cxx:1751
 TBranchElement.cxx:1752
 TBranchElement.cxx:1753
 TBranchElement.cxx:1754
 TBranchElement.cxx:1755
 TBranchElement.cxx:1756
 TBranchElement.cxx:1757
 TBranchElement.cxx:1758
 TBranchElement.cxx:1759
 TBranchElement.cxx:1760
 TBranchElement.cxx:1761
 TBranchElement.cxx:1762
 TBranchElement.cxx:1763
 TBranchElement.cxx:1764
 TBranchElement.cxx:1765
 TBranchElement.cxx:1766
 TBranchElement.cxx:1767
 TBranchElement.cxx:1768
 TBranchElement.cxx:1769
 TBranchElement.cxx:1770
 TBranchElement.cxx:1771
 TBranchElement.cxx:1772
 TBranchElement.cxx:1773
 TBranchElement.cxx:1774
 TBranchElement.cxx:1775
 TBranchElement.cxx:1776
 TBranchElement.cxx:1777
 TBranchElement.cxx:1778
 TBranchElement.cxx:1779
 TBranchElement.cxx:1780
 TBranchElement.cxx:1781
 TBranchElement.cxx:1782
 TBranchElement.cxx:1783
 TBranchElement.cxx:1784
 TBranchElement.cxx:1785
 TBranchElement.cxx:1786
 TBranchElement.cxx:1787
 TBranchElement.cxx:1788
 TBranchElement.cxx:1789
 TBranchElement.cxx:1790
 TBranchElement.cxx:1791
 TBranchElement.cxx:1792
 TBranchElement.cxx:1793
 TBranchElement.cxx:1794
 TBranchElement.cxx:1795
 TBranchElement.cxx:1796
 TBranchElement.cxx:1797
 TBranchElement.cxx:1798
 TBranchElement.cxx:1799
 TBranchElement.cxx:1800
 TBranchElement.cxx:1801
 TBranchElement.cxx:1802
 TBranchElement.cxx:1803
 TBranchElement.cxx:1804
 TBranchElement.cxx:1805
 TBranchElement.cxx:1806
 TBranchElement.cxx:1807
 TBranchElement.cxx:1808
 TBranchElement.cxx:1809
 TBranchElement.cxx:1810
 TBranchElement.cxx:1811
 TBranchElement.cxx:1812
 TBranchElement.cxx:1813
 TBranchElement.cxx:1814
 TBranchElement.cxx:1815
 TBranchElement.cxx:1816
 TBranchElement.cxx:1817
 TBranchElement.cxx:1818
 TBranchElement.cxx:1819
 TBranchElement.cxx:1820
 TBranchElement.cxx:1821
 TBranchElement.cxx:1822
 TBranchElement.cxx:1823
 TBranchElement.cxx:1824
 TBranchElement.cxx:1825
 TBranchElement.cxx:1826
 TBranchElement.cxx:1827
 TBranchElement.cxx:1828
 TBranchElement.cxx:1829
 TBranchElement.cxx:1830
 TBranchElement.cxx:1831
 TBranchElement.cxx:1832
 TBranchElement.cxx:1833
 TBranchElement.cxx:1834
 TBranchElement.cxx:1835
 TBranchElement.cxx:1836
 TBranchElement.cxx:1837
 TBranchElement.cxx:1838
 TBranchElement.cxx:1839
 TBranchElement.cxx:1840
 TBranchElement.cxx:1841
 TBranchElement.cxx:1842
 TBranchElement.cxx:1843
 TBranchElement.cxx:1844
 TBranchElement.cxx:1845
 TBranchElement.cxx:1846
 TBranchElement.cxx:1847
 TBranchElement.cxx:1848
 TBranchElement.cxx:1849
 TBranchElement.cxx:1850
 TBranchElement.cxx:1851
 TBranchElement.cxx:1852
 TBranchElement.cxx:1853
 TBranchElement.cxx:1854
 TBranchElement.cxx:1855
 TBranchElement.cxx:1856
 TBranchElement.cxx:1857
 TBranchElement.cxx:1858
 TBranchElement.cxx:1859
 TBranchElement.cxx:1860
 TBranchElement.cxx:1861
 TBranchElement.cxx:1862
 TBranchElement.cxx:1863
 TBranchElement.cxx:1864
 TBranchElement.cxx:1865
 TBranchElement.cxx:1866
 TBranchElement.cxx:1867
 TBranchElement.cxx:1868
 TBranchElement.cxx:1869
 TBranchElement.cxx:1870
 TBranchElement.cxx:1871
 TBranchElement.cxx:1872
 TBranchElement.cxx:1873
 TBranchElement.cxx:1874
 TBranchElement.cxx:1875
 TBranchElement.cxx:1876
 TBranchElement.cxx:1877
 TBranchElement.cxx:1878
 TBranchElement.cxx:1879
 TBranchElement.cxx:1880
 TBranchElement.cxx:1881
 TBranchElement.cxx:1882
 TBranchElement.cxx:1883
 TBranchElement.cxx:1884
 TBranchElement.cxx:1885
 TBranchElement.cxx:1886
 TBranchElement.cxx:1887
 TBranchElement.cxx:1888
 TBranchElement.cxx:1889
 TBranchElement.cxx:1890
 TBranchElement.cxx:1891
 TBranchElement.cxx:1892
 TBranchElement.cxx:1893
 TBranchElement.cxx:1894
 TBranchElement.cxx:1895
 TBranchElement.cxx:1896
 TBranchElement.cxx:1897
 TBranchElement.cxx:1898
 TBranchElement.cxx:1899
 TBranchElement.cxx:1900
 TBranchElement.cxx:1901
 TBranchElement.cxx:1902
 TBranchElement.cxx:1903
 TBranchElement.cxx:1904
 TBranchElement.cxx:1905
 TBranchElement.cxx:1906
 TBranchElement.cxx:1907
 TBranchElement.cxx:1908
 TBranchElement.cxx:1909
 TBranchElement.cxx:1910
 TBranchElement.cxx:1911
 TBranchElement.cxx:1912
 TBranchElement.cxx:1913
 TBranchElement.cxx:1914
 TBranchElement.cxx:1915
 TBranchElement.cxx:1916
 TBranchElement.cxx:1917
 TBranchElement.cxx:1918
 TBranchElement.cxx:1919
 TBranchElement.cxx:1920
 TBranchElement.cxx:1921
 TBranchElement.cxx:1922
 TBranchElement.cxx:1923
 TBranchElement.cxx:1924
 TBranchElement.cxx:1925
 TBranchElement.cxx:1926
 TBranchElement.cxx:1927
 TBranchElement.cxx:1928
 TBranchElement.cxx:1929
 TBranchElement.cxx:1930
 TBranchElement.cxx:1931
 TBranchElement.cxx:1932
 TBranchElement.cxx:1933
 TBranchElement.cxx:1934
 TBranchElement.cxx:1935
 TBranchElement.cxx:1936
 TBranchElement.cxx:1937
 TBranchElement.cxx:1938
 TBranchElement.cxx:1939
 TBranchElement.cxx:1940
 TBranchElement.cxx:1941
 TBranchElement.cxx:1942
 TBranchElement.cxx:1943
 TBranchElement.cxx:1944
 TBranchElement.cxx:1945
 TBranchElement.cxx:1946
 TBranchElement.cxx:1947
 TBranchElement.cxx:1948
 TBranchElement.cxx:1949
 TBranchElement.cxx:1950
 TBranchElement.cxx:1951
 TBranchElement.cxx:1952
 TBranchElement.cxx:1953
 TBranchElement.cxx:1954
 TBranchElement.cxx:1955
 TBranchElement.cxx:1956
 TBranchElement.cxx:1957
 TBranchElement.cxx:1958
 TBranchElement.cxx:1959
 TBranchElement.cxx:1960
 TBranchElement.cxx:1961
 TBranchElement.cxx:1962
 TBranchElement.cxx:1963
 TBranchElement.cxx:1964
 TBranchElement.cxx:1965
 TBranchElement.cxx:1966
 TBranchElement.cxx:1967
 TBranchElement.cxx:1968
 TBranchElement.cxx:1969
 TBranchElement.cxx:1970
 TBranchElement.cxx:1971
 TBranchElement.cxx:1972
 TBranchElement.cxx:1973
 TBranchElement.cxx:1974
 TBranchElement.cxx:1975
 TBranchElement.cxx:1976
 TBranchElement.cxx:1977
 TBranchElement.cxx:1978
 TBranchElement.cxx:1979
 TBranchElement.cxx:1980
 TBranchElement.cxx:1981
 TBranchElement.cxx:1982
 TBranchElement.cxx:1983
 TBranchElement.cxx:1984
 TBranchElement.cxx:1985
 TBranchElement.cxx:1986
 TBranchElement.cxx:1987
 TBranchElement.cxx:1988
 TBranchElement.cxx:1989
 TBranchElement.cxx:1990
 TBranchElement.cxx:1991
 TBranchElement.cxx:1992
 TBranchElement.cxx:1993
 TBranchElement.cxx:1994
 TBranchElement.cxx:1995
 TBranchElement.cxx:1996
 TBranchElement.cxx:1997
 TBranchElement.cxx:1998
 TBranchElement.cxx:1999
 TBranchElement.cxx:2000
 TBranchElement.cxx:2001
 TBranchElement.cxx:2002
 TBranchElement.cxx:2003
 TBranchElement.cxx:2004
 TBranchElement.cxx:2005
 TBranchElement.cxx:2006
 TBranchElement.cxx:2007
 TBranchElement.cxx:2008
 TBranchElement.cxx:2009
 TBranchElement.cxx:2010
 TBranchElement.cxx:2011
 TBranchElement.cxx:2012
 TBranchElement.cxx:2013
 TBranchElement.cxx:2014
 TBranchElement.cxx:2015
 TBranchElement.cxx:2016
 TBranchElement.cxx:2017
 TBranchElement.cxx:2018
 TBranchElement.cxx:2019
 TBranchElement.cxx:2020
 TBranchElement.cxx:2021
 TBranchElement.cxx:2022
 TBranchElement.cxx:2023
 TBranchElement.cxx:2024
 TBranchElement.cxx:2025
 TBranchElement.cxx:2026
 TBranchElement.cxx:2027
 TBranchElement.cxx:2028
 TBranchElement.cxx:2029
 TBranchElement.cxx:2030
 TBranchElement.cxx:2031
 TBranchElement.cxx:2032
 TBranchElement.cxx:2033
 TBranchElement.cxx:2034
 TBranchElement.cxx:2035
 TBranchElement.cxx:2036
 TBranchElement.cxx:2037
 TBranchElement.cxx:2038
 TBranchElement.cxx:2039
 TBranchElement.cxx:2040
 TBranchElement.cxx:2041
 TBranchElement.cxx:2042
 TBranchElement.cxx:2043
 TBranchElement.cxx:2044
 TBranchElement.cxx:2045
 TBranchElement.cxx:2046
 TBranchElement.cxx:2047
 TBranchElement.cxx:2048
 TBranchElement.cxx:2049
 TBranchElement.cxx:2050
 TBranchElement.cxx:2051
 TBranchElement.cxx:2052
 TBranchElement.cxx:2053
 TBranchElement.cxx:2054
 TBranchElement.cxx:2055
 TBranchElement.cxx:2056
 TBranchElement.cxx:2057
 TBranchElement.cxx:2058
 TBranchElement.cxx:2059
 TBranchElement.cxx:2060
 TBranchElement.cxx:2061
 TBranchElement.cxx:2062
 TBranchElement.cxx:2063
 TBranchElement.cxx:2064
 TBranchElement.cxx:2065
 TBranchElement.cxx:2066
 TBranchElement.cxx:2067
 TBranchElement.cxx:2068
 TBranchElement.cxx:2069
 TBranchElement.cxx:2070
 TBranchElement.cxx:2071
 TBranchElement.cxx:2072
 TBranchElement.cxx:2073
 TBranchElement.cxx:2074
 TBranchElement.cxx:2075
 TBranchElement.cxx:2076
 TBranchElement.cxx:2077
 TBranchElement.cxx:2078
 TBranchElement.cxx:2079
 TBranchElement.cxx:2080
 TBranchElement.cxx:2081
 TBranchElement.cxx:2082
 TBranchElement.cxx:2083
 TBranchElement.cxx:2084
 TBranchElement.cxx:2085
 TBranchElement.cxx:2086
 TBranchElement.cxx:2087
 TBranchElement.cxx:2088
 TBranchElement.cxx:2089
 TBranchElement.cxx:2090
 TBranchElement.cxx:2091
 TBranchElement.cxx:2092
 TBranchElement.cxx:2093
 TBranchElement.cxx:2094
 TBranchElement.cxx:2095
 TBranchElement.cxx:2096
 TBranchElement.cxx:2097
 TBranchElement.cxx:2098
 TBranchElement.cxx:2099
 TBranchElement.cxx:2100
 TBranchElement.cxx:2101
 TBranchElement.cxx:2102
 TBranchElement.cxx:2103
 TBranchElement.cxx:2104
 TBranchElement.cxx:2105
 TBranchElement.cxx:2106
 TBranchElement.cxx:2107
 TBranchElement.cxx:2108
 TBranchElement.cxx:2109
 TBranchElement.cxx:2110
 TBranchElement.cxx:2111
 TBranchElement.cxx:2112
 TBranchElement.cxx:2113
 TBranchElement.cxx:2114
 TBranchElement.cxx:2115
 TBranchElement.cxx:2116
 TBranchElement.cxx:2117
 TBranchElement.cxx:2118
 TBranchElement.cxx:2119
 TBranchElement.cxx:2120
 TBranchElement.cxx:2121
 TBranchElement.cxx:2122
 TBranchElement.cxx:2123
 TBranchElement.cxx:2124
 TBranchElement.cxx:2125
 TBranchElement.cxx:2126
 TBranchElement.cxx:2127
 TBranchElement.cxx:2128
 TBranchElement.cxx:2129
 TBranchElement.cxx:2130
 TBranchElement.cxx:2131
 TBranchElement.cxx:2132
 TBranchElement.cxx:2133
 TBranchElement.cxx:2134
 TBranchElement.cxx:2135
 TBranchElement.cxx:2136
 TBranchElement.cxx:2137
 TBranchElement.cxx:2138
 TBranchElement.cxx:2139
 TBranchElement.cxx:2140
 TBranchElement.cxx:2141
 TBranchElement.cxx:2142
 TBranchElement.cxx:2143
 TBranchElement.cxx:2144
 TBranchElement.cxx:2145
 TBranchElement.cxx:2146
 TBranchElement.cxx:2147
 TBranchElement.cxx:2148
 TBranchElement.cxx:2149
 TBranchElement.cxx:2150
 TBranchElement.cxx:2151
 TBranchElement.cxx:2152
 TBranchElement.cxx:2153
 TBranchElement.cxx:2154
 TBranchElement.cxx:2155
 TBranchElement.cxx:2156
 TBranchElement.cxx:2157
 TBranchElement.cxx:2158
 TBranchElement.cxx:2159
 TBranchElement.cxx:2160
 TBranchElement.cxx:2161
 TBranchElement.cxx:2162
 TBranchElement.cxx:2163
 TBranchElement.cxx:2164
 TBranchElement.cxx:2165
 TBranchElement.cxx:2166
 TBranchElement.cxx:2167
 TBranchElement.cxx:2168
 TBranchElement.cxx:2169
 TBranchElement.cxx:2170
 TBranchElement.cxx:2171
 TBranchElement.cxx:2172
 TBranchElement.cxx:2173
 TBranchElement.cxx:2174
 TBranchElement.cxx:2175
 TBranchElement.cxx:2176
 TBranchElement.cxx:2177
 TBranchElement.cxx:2178
 TBranchElement.cxx:2179
 TBranchElement.cxx:2180
 TBranchElement.cxx:2181
 TBranchElement.cxx:2182
 TBranchElement.cxx:2183
 TBranchElement.cxx:2184
 TBranchElement.cxx:2185
 TBranchElement.cxx:2186
 TBranchElement.cxx:2187
 TBranchElement.cxx:2188
 TBranchElement.cxx:2189
 TBranchElement.cxx:2190
 TBranchElement.cxx:2191
 TBranchElement.cxx:2192
 TBranchElement.cxx:2193
 TBranchElement.cxx:2194
 TBranchElement.cxx:2195
 TBranchElement.cxx:2196
 TBranchElement.cxx:2197
 TBranchElement.cxx:2198
 TBranchElement.cxx:2199
 TBranchElement.cxx:2200
 TBranchElement.cxx:2201
 TBranchElement.cxx:2202
 TBranchElement.cxx:2203
 TBranchElement.cxx:2204
 TBranchElement.cxx:2205
 TBranchElement.cxx:2206
 TBranchElement.cxx:2207
 TBranchElement.cxx:2208
 TBranchElement.cxx:2209
 TBranchElement.cxx:2210
 TBranchElement.cxx:2211
 TBranchElement.cxx:2212
 TBranchElement.cxx:2213
 TBranchElement.cxx:2214
 TBranchElement.cxx:2215
 TBranchElement.cxx:2216
 TBranchElement.cxx:2217
 TBranchElement.cxx:2218
 TBranchElement.cxx:2219
 TBranchElement.cxx:2220
 TBranchElement.cxx:2221
 TBranchElement.cxx:2222
 TBranchElement.cxx:2223
 TBranchElement.cxx:2224
 TBranchElement.cxx:2225
 TBranchElement.cxx:2226
 TBranchElement.cxx:2227
 TBranchElement.cxx:2228
 TBranchElement.cxx:2229
 TBranchElement.cxx:2230
 TBranchElement.cxx:2231
 TBranchElement.cxx:2232
 TBranchElement.cxx:2233
 TBranchElement.cxx:2234
 TBranchElement.cxx:2235
 TBranchElement.cxx:2236
 TBranchElement.cxx:2237
 TBranchElement.cxx:2238
 TBranchElement.cxx:2239
 TBranchElement.cxx:2240
 TBranchElement.cxx:2241
 TBranchElement.cxx:2242
 TBranchElement.cxx:2243
 TBranchElement.cxx:2244
 TBranchElement.cxx:2245
 TBranchElement.cxx:2246
 TBranchElement.cxx:2247
 TBranchElement.cxx:2248
 TBranchElement.cxx:2249
 TBranchElement.cxx:2250
 TBranchElement.cxx:2251
 TBranchElement.cxx:2252
 TBranchElement.cxx:2253
 TBranchElement.cxx:2254
 TBranchElement.cxx:2255
 TBranchElement.cxx:2256
 TBranchElement.cxx:2257
 TBranchElement.cxx:2258
 TBranchElement.cxx:2259
 TBranchElement.cxx:2260
 TBranchElement.cxx:2261
 TBranchElement.cxx:2262
 TBranchElement.cxx:2263
 TBranchElement.cxx:2264
 TBranchElement.cxx:2265
 TBranchElement.cxx:2266
 TBranchElement.cxx:2267
 TBranchElement.cxx:2268
 TBranchElement.cxx:2269
 TBranchElement.cxx:2270
 TBranchElement.cxx:2271
 TBranchElement.cxx:2272
 TBranchElement.cxx:2273
 TBranchElement.cxx:2274
 TBranchElement.cxx:2275
 TBranchElement.cxx:2276
 TBranchElement.cxx:2277
 TBranchElement.cxx:2278
 TBranchElement.cxx:2279
 TBranchElement.cxx:2280
 TBranchElement.cxx:2281
 TBranchElement.cxx:2282
 TBranchElement.cxx:2283
 TBranchElement.cxx:2284
 TBranchElement.cxx:2285
 TBranchElement.cxx:2286
 TBranchElement.cxx:2287
 TBranchElement.cxx:2288
 TBranchElement.cxx:2289
 TBranchElement.cxx:2290
 TBranchElement.cxx:2291
 TBranchElement.cxx:2292
 TBranchElement.cxx:2293
 TBranchElement.cxx:2294
 TBranchElement.cxx:2295
 TBranchElement.cxx:2296
 TBranchElement.cxx:2297
 TBranchElement.cxx:2298
 TBranchElement.cxx:2299
 TBranchElement.cxx:2300
 TBranchElement.cxx:2301
 TBranchElement.cxx:2302
 TBranchElement.cxx:2303
 TBranchElement.cxx:2304
 TBranchElement.cxx:2305
 TBranchElement.cxx:2306
 TBranchElement.cxx:2307
 TBranchElement.cxx:2308
 TBranchElement.cxx:2309
 TBranchElement.cxx:2310
 TBranchElement.cxx:2311
 TBranchElement.cxx:2312
 TBranchElement.cxx:2313
 TBranchElement.cxx:2314
 TBranchElement.cxx:2315
 TBranchElement.cxx:2316
 TBranchElement.cxx:2317
 TBranchElement.cxx:2318
 TBranchElement.cxx:2319
 TBranchElement.cxx:2320
 TBranchElement.cxx:2321
 TBranchElement.cxx:2322
 TBranchElement.cxx:2323
 TBranchElement.cxx:2324
 TBranchElement.cxx:2325
 TBranchElement.cxx:2326
 TBranchElement.cxx:2327
 TBranchElement.cxx:2328
 TBranchElement.cxx:2329
 TBranchElement.cxx:2330
 TBranchElement.cxx:2331
 TBranchElement.cxx:2332
 TBranchElement.cxx:2333
 TBranchElement.cxx:2334
 TBranchElement.cxx:2335
 TBranchElement.cxx:2336
 TBranchElement.cxx:2337
 TBranchElement.cxx:2338
 TBranchElement.cxx:2339
 TBranchElement.cxx:2340
 TBranchElement.cxx:2341
 TBranchElement.cxx:2342
 TBranchElement.cxx:2343
 TBranchElement.cxx:2344
 TBranchElement.cxx:2345
 TBranchElement.cxx:2346
 TBranchElement.cxx:2347
 TBranchElement.cxx:2348
 TBranchElement.cxx:2349
 TBranchElement.cxx:2350
 TBranchElement.cxx:2351
 TBranchElement.cxx:2352
 TBranchElement.cxx:2353
 TBranchElement.cxx:2354
 TBranchElement.cxx:2355
 TBranchElement.cxx:2356
 TBranchElement.cxx:2357
 TBranchElement.cxx:2358
 TBranchElement.cxx:2359
 TBranchElement.cxx:2360
 TBranchElement.cxx:2361
 TBranchElement.cxx:2362
 TBranchElement.cxx:2363
 TBranchElement.cxx:2364
 TBranchElement.cxx:2365
 TBranchElement.cxx:2366
 TBranchElement.cxx:2367
 TBranchElement.cxx:2368
 TBranchElement.cxx:2369
 TBranchElement.cxx:2370
 TBranchElement.cxx:2371
 TBranchElement.cxx:2372
 TBranchElement.cxx:2373
 TBranchElement.cxx:2374
 TBranchElement.cxx:2375
 TBranchElement.cxx:2376
 TBranchElement.cxx:2377
 TBranchElement.cxx:2378
 TBranchElement.cxx:2379
 TBranchElement.cxx:2380
 TBranchElement.cxx:2381
 TBranchElement.cxx:2382
 TBranchElement.cxx:2383
 TBranchElement.cxx:2384
 TBranchElement.cxx:2385
 TBranchElement.cxx:2386
 TBranchElement.cxx:2387
 TBranchElement.cxx:2388
 TBranchElement.cxx:2389
 TBranchElement.cxx:2390
 TBranchElement.cxx:2391
 TBranchElement.cxx:2392
 TBranchElement.cxx:2393
 TBranchElement.cxx:2394
 TBranchElement.cxx:2395
 TBranchElement.cxx:2396
 TBranchElement.cxx:2397
 TBranchElement.cxx:2398
 TBranchElement.cxx:2399
 TBranchElement.cxx:2400
 TBranchElement.cxx:2401
 TBranchElement.cxx:2402
 TBranchElement.cxx:2403
 TBranchElement.cxx:2404
 TBranchElement.cxx:2405
 TBranchElement.cxx:2406
 TBranchElement.cxx:2407
 TBranchElement.cxx:2408
 TBranchElement.cxx:2409
 TBranchElement.cxx:2410
 TBranchElement.cxx:2411
 TBranchElement.cxx:2412
 TBranchElement.cxx:2413
 TBranchElement.cxx:2414
 TBranchElement.cxx:2415
 TBranchElement.cxx:2416
 TBranchElement.cxx:2417
 TBranchElement.cxx:2418
 TBranchElement.cxx:2419
 TBranchElement.cxx:2420
 TBranchElement.cxx:2421
 TBranchElement.cxx:2422
 TBranchElement.cxx:2423
 TBranchElement.cxx:2424
 TBranchElement.cxx:2425
 TBranchElement.cxx:2426
 TBranchElement.cxx:2427
 TBranchElement.cxx:2428
 TBranchElement.cxx:2429
 TBranchElement.cxx:2430
 TBranchElement.cxx:2431
 TBranchElement.cxx:2432
 TBranchElement.cxx:2433
 TBranchElement.cxx:2434
 TBranchElement.cxx:2435
 TBranchElement.cxx:2436
 TBranchElement.cxx:2437
 TBranchElement.cxx:2438
 TBranchElement.cxx:2439
 TBranchElement.cxx:2440
 TBranchElement.cxx:2441
 TBranchElement.cxx:2442
 TBranchElement.cxx:2443
 TBranchElement.cxx:2444
 TBranchElement.cxx:2445
 TBranchElement.cxx:2446
 TBranchElement.cxx:2447
 TBranchElement.cxx:2448
 TBranchElement.cxx:2449
 TBranchElement.cxx:2450
 TBranchElement.cxx:2451
 TBranchElement.cxx:2452
 TBranchElement.cxx:2453
 TBranchElement.cxx:2454
 TBranchElement.cxx:2455
 TBranchElement.cxx:2456
 TBranchElement.cxx:2457
 TBranchElement.cxx:2458
 TBranchElement.cxx:2459
 TBranchElement.cxx:2460
 TBranchElement.cxx:2461
 TBranchElement.cxx:2462
 TBranchElement.cxx:2463
 TBranchElement.cxx:2464
 TBranchElement.cxx:2465
 TBranchElement.cxx:2466
 TBranchElement.cxx:2467
 TBranchElement.cxx:2468
 TBranchElement.cxx:2469
 TBranchElement.cxx:2470
 TBranchElement.cxx:2471
 TBranchElement.cxx:2472
 TBranchElement.cxx:2473
 TBranchElement.cxx:2474
 TBranchElement.cxx:2475
 TBranchElement.cxx:2476
 TBranchElement.cxx:2477
 TBranchElement.cxx:2478
 TBranchElement.cxx:2479
 TBranchElement.cxx:2480
 TBranchElement.cxx:2481
 TBranchElement.cxx:2482
 TBranchElement.cxx:2483
 TBranchElement.cxx:2484
 TBranchElement.cxx:2485
 TBranchElement.cxx:2486
 TBranchElement.cxx:2487
 TBranchElement.cxx:2488
 TBranchElement.cxx:2489
 TBranchElement.cxx:2490
 TBranchElement.cxx:2491
 TBranchElement.cxx:2492
 TBranchElement.cxx:2493
 TBranchElement.cxx:2494
 TBranchElement.cxx:2495
 TBranchElement.cxx:2496
 TBranchElement.cxx:2497
 TBranchElement.cxx:2498
 TBranchElement.cxx:2499
 TBranchElement.cxx:2500
 TBranchElement.cxx:2501
 TBranchElement.cxx:2502
 TBranchElement.cxx:2503
 TBranchElement.cxx:2504
 TBranchElement.cxx:2505
 TBranchElement.cxx:2506
 TBranchElement.cxx:2507
 TBranchElement.cxx:2508
 TBranchElement.cxx:2509
 TBranchElement.cxx:2510
 TBranchElement.cxx:2511
 TBranchElement.cxx:2512
 TBranchElement.cxx:2513
 TBranchElement.cxx:2514
 TBranchElement.cxx:2515
 TBranchElement.cxx:2516
 TBranchElement.cxx:2517
 TBranchElement.cxx:2518
 TBranchElement.cxx:2519
 TBranchElement.cxx:2520
 TBranchElement.cxx:2521
 TBranchElement.cxx:2522
 TBranchElement.cxx:2523
 TBranchElement.cxx:2524
 TBranchElement.cxx:2525
 TBranchElement.cxx:2526
 TBranchElement.cxx:2527
 TBranchElement.cxx:2528
 TBranchElement.cxx:2529
 TBranchElement.cxx:2530
 TBranchElement.cxx:2531
 TBranchElement.cxx:2532
 TBranchElement.cxx:2533
 TBranchElement.cxx:2534
 TBranchElement.cxx:2535
 TBranchElement.cxx:2536
 TBranchElement.cxx:2537
 TBranchElement.cxx:2538
 TBranchElement.cxx:2539
 TBranchElement.cxx:2540
 TBranchElement.cxx:2541
 TBranchElement.cxx:2542
 TBranchElement.cxx:2543
 TBranchElement.cxx:2544
 TBranchElement.cxx:2545
 TBranchElement.cxx:2546
 TBranchElement.cxx:2547
 TBranchElement.cxx:2548
 TBranchElement.cxx:2549
 TBranchElement.cxx:2550
 TBranchElement.cxx:2551
 TBranchElement.cxx:2552
 TBranchElement.cxx:2553
 TBranchElement.cxx:2554
 TBranchElement.cxx:2555
 TBranchElement.cxx:2556
 TBranchElement.cxx:2557
 TBranchElement.cxx:2558
 TBranchElement.cxx:2559
 TBranchElement.cxx:2560
 TBranchElement.cxx:2561
 TBranchElement.cxx:2562
 TBranchElement.cxx:2563
 TBranchElement.cxx:2564
 TBranchElement.cxx:2565
 TBranchElement.cxx:2566
 TBranchElement.cxx:2567
 TBranchElement.cxx:2568
 TBranchElement.cxx:2569
 TBranchElement.cxx:2570
 TBranchElement.cxx:2571
 TBranchElement.cxx:2572
 TBranchElement.cxx:2573
 TBranchElement.cxx:2574
 TBranchElement.cxx:2575
 TBranchElement.cxx:2576
 TBranchElement.cxx:2577
 TBranchElement.cxx:2578
 TBranchElement.cxx:2579
 TBranchElement.cxx:2580
 TBranchElement.cxx:2581
 TBranchElement.cxx:2582
 TBranchElement.cxx:2583
 TBranchElement.cxx:2584
 TBranchElement.cxx:2585
 TBranchElement.cxx:2586
 TBranchElement.cxx:2587
 TBranchElement.cxx:2588
 TBranchElement.cxx:2589
 TBranchElement.cxx:2590
 TBranchElement.cxx:2591
 TBranchElement.cxx:2592
 TBranchElement.cxx:2593
 TBranchElement.cxx:2594
 TBranchElement.cxx:2595
 TBranchElement.cxx:2596
 TBranchElement.cxx:2597
 TBranchElement.cxx:2598
 TBranchElement.cxx:2599
 TBranchElement.cxx:2600
 TBranchElement.cxx:2601
 TBranchElement.cxx:2602
 TBranchElement.cxx:2603
 TBranchElement.cxx:2604
 TBranchElement.cxx:2605
 TBranchElement.cxx:2606
 TBranchElement.cxx:2607
 TBranchElement.cxx:2608
 TBranchElement.cxx:2609
 TBranchElement.cxx:2610
 TBranchElement.cxx:2611
 TBranchElement.cxx:2612
 TBranchElement.cxx:2613
 TBranchElement.cxx:2614
 TBranchElement.cxx:2615
 TBranchElement.cxx:2616
 TBranchElement.cxx:2617
 TBranchElement.cxx:2618
 TBranchElement.cxx:2619
 TBranchElement.cxx:2620
 TBranchElement.cxx:2621
 TBranchElement.cxx:2622
 TBranchElement.cxx:2623
 TBranchElement.cxx:2624
 TBranchElement.cxx:2625
 TBranchElement.cxx:2626
 TBranchElement.cxx:2627
 TBranchElement.cxx:2628
 TBranchElement.cxx:2629
 TBranchElement.cxx:2630
 TBranchElement.cxx:2631
 TBranchElement.cxx:2632
 TBranchElement.cxx:2633
 TBranchElement.cxx:2634
 TBranchElement.cxx:2635
 TBranchElement.cxx:2636
 TBranchElement.cxx:2637
 TBranchElement.cxx:2638
 TBranchElement.cxx:2639
 TBranchElement.cxx:2640
 TBranchElement.cxx:2641
 TBranchElement.cxx:2642
 TBranchElement.cxx:2643
 TBranchElement.cxx:2644
 TBranchElement.cxx:2645
 TBranchElement.cxx:2646
 TBranchElement.cxx:2647
 TBranchElement.cxx:2648
 TBranchElement.cxx:2649
 TBranchElement.cxx:2650
 TBranchElement.cxx:2651
 TBranchElement.cxx:2652
 TBranchElement.cxx:2653
 TBranchElement.cxx:2654
 TBranchElement.cxx:2655
 TBranchElement.cxx:2656
 TBranchElement.cxx:2657
 TBranchElement.cxx:2658
 TBranchElement.cxx:2659
 TBranchElement.cxx:2660
 TBranchElement.cxx:2661
 TBranchElement.cxx:2662
 TBranchElement.cxx:2663
 TBranchElement.cxx:2664
 TBranchElement.cxx:2665
 TBranchElement.cxx:2666
 TBranchElement.cxx:2667
 TBranchElement.cxx:2668
 TBranchElement.cxx:2669
 TBranchElement.cxx:2670
 TBranchElement.cxx:2671
 TBranchElement.cxx:2672
 TBranchElement.cxx:2673
 TBranchElement.cxx:2674
 TBranchElement.cxx:2675
 TBranchElement.cxx:2676
 TBranchElement.cxx:2677
 TBranchElement.cxx:2678
 TBranchElement.cxx:2679
 TBranchElement.cxx:2680
 TBranchElement.cxx:2681
 TBranchElement.cxx:2682
 TBranchElement.cxx:2683
 TBranchElement.cxx:2684
 TBranchElement.cxx:2685
 TBranchElement.cxx:2686
 TBranchElement.cxx:2687
 TBranchElement.cxx:2688
 TBranchElement.cxx:2689
 TBranchElement.cxx:2690
 TBranchElement.cxx:2691
 TBranchElement.cxx:2692
 TBranchElement.cxx:2693
 TBranchElement.cxx:2694
 TBranchElement.cxx:2695
 TBranchElement.cxx:2696
 TBranchElement.cxx:2697
 TBranchElement.cxx:2698
 TBranchElement.cxx:2699
 TBranchElement.cxx:2700
 TBranchElement.cxx:2701
 TBranchElement.cxx:2702
 TBranchElement.cxx:2703
 TBranchElement.cxx:2704
 TBranchElement.cxx:2705
 TBranchElement.cxx:2706
 TBranchElement.cxx:2707
 TBranchElement.cxx:2708
 TBranchElement.cxx:2709
 TBranchElement.cxx:2710
 TBranchElement.cxx:2711
 TBranchElement.cxx:2712
 TBranchElement.cxx:2713
 TBranchElement.cxx:2714
 TBranchElement.cxx:2715
 TBranchElement.cxx:2716
 TBranchElement.cxx:2717
 TBranchElement.cxx:2718
 TBranchElement.cxx:2719
 TBranchElement.cxx:2720
 TBranchElement.cxx:2721
 TBranchElement.cxx:2722
 TBranchElement.cxx:2723
 TBranchElement.cxx:2724
 TBranchElement.cxx:2725
 TBranchElement.cxx:2726
 TBranchElement.cxx:2727
 TBranchElement.cxx:2728
 TBranchElement.cxx:2729
 TBranchElement.cxx:2730
 TBranchElement.cxx:2731
 TBranchElement.cxx:2732
 TBranchElement.cxx:2733
 TBranchElement.cxx:2734
 TBranchElement.cxx:2735
 TBranchElement.cxx:2736
 TBranchElement.cxx:2737
 TBranchElement.cxx:2738
 TBranchElement.cxx:2739
 TBranchElement.cxx:2740
 TBranchElement.cxx:2741
 TBranchElement.cxx:2742
 TBranchElement.cxx:2743
 TBranchElement.cxx:2744
 TBranchElement.cxx:2745
 TBranchElement.cxx:2746
 TBranchElement.cxx:2747
 TBranchElement.cxx:2748
 TBranchElement.cxx:2749
 TBranchElement.cxx:2750
 TBranchElement.cxx:2751
 TBranchElement.cxx:2752
 TBranchElement.cxx:2753
 TBranchElement.cxx:2754
 TBranchElement.cxx:2755
 TBranchElement.cxx:2756
 TBranchElement.cxx:2757
 TBranchElement.cxx:2758
 TBranchElement.cxx:2759
 TBranchElement.cxx:2760
 TBranchElement.cxx:2761
 TBranchElement.cxx:2762
 TBranchElement.cxx:2763
 TBranchElement.cxx:2764
 TBranchElement.cxx:2765
 TBranchElement.cxx:2766
 TBranchElement.cxx:2767
 TBranchElement.cxx:2768
 TBranchElement.cxx:2769
 TBranchElement.cxx:2770
 TBranchElement.cxx:2771
 TBranchElement.cxx:2772
 TBranchElement.cxx:2773
 TBranchElement.cxx:2774
 TBranchElement.cxx:2775
 TBranchElement.cxx:2776
 TBranchElement.cxx:2777
 TBranchElement.cxx:2778
 TBranchElement.cxx:2779
 TBranchElement.cxx:2780
 TBranchElement.cxx:2781
 TBranchElement.cxx:2782
 TBranchElement.cxx:2783
 TBranchElement.cxx:2784
 TBranchElement.cxx:2785
 TBranchElement.cxx:2786
 TBranchElement.cxx:2787
 TBranchElement.cxx:2788
 TBranchElement.cxx:2789
 TBranchElement.cxx:2790
 TBranchElement.cxx:2791
 TBranchElement.cxx:2792
 TBranchElement.cxx:2793
 TBranchElement.cxx:2794
 TBranchElement.cxx:2795
 TBranchElement.cxx:2796
 TBranchElement.cxx:2797
 TBranchElement.cxx:2798
 TBranchElement.cxx:2799
 TBranchElement.cxx:2800
 TBranchElement.cxx:2801
 TBranchElement.cxx:2802
 TBranchElement.cxx:2803
 TBranchElement.cxx:2804
 TBranchElement.cxx:2805
 TBranchElement.cxx:2806
 TBranchElement.cxx:2807
 TBranchElement.cxx:2808
 TBranchElement.cxx:2809
 TBranchElement.cxx:2810
 TBranchElement.cxx:2811
 TBranchElement.cxx:2812
 TBranchElement.cxx:2813
 TBranchElement.cxx:2814
 TBranchElement.cxx:2815
 TBranchElement.cxx:2816
 TBranchElement.cxx:2817
 TBranchElement.cxx:2818
 TBranchElement.cxx:2819
 TBranchElement.cxx:2820
 TBranchElement.cxx:2821
 TBranchElement.cxx:2822
 TBranchElement.cxx:2823
 TBranchElement.cxx:2824
 TBranchElement.cxx:2825
 TBranchElement.cxx:2826
 TBranchElement.cxx:2827
 TBranchElement.cxx:2828
 TBranchElement.cxx:2829
 TBranchElement.cxx:2830
 TBranchElement.cxx:2831
 TBranchElement.cxx:2832
 TBranchElement.cxx:2833
 TBranchElement.cxx:2834
 TBranchElement.cxx:2835
 TBranchElement.cxx:2836
 TBranchElement.cxx:2837
 TBranchElement.cxx:2838
 TBranchElement.cxx:2839
 TBranchElement.cxx:2840
 TBranchElement.cxx:2841
 TBranchElement.cxx:2842
 TBranchElement.cxx:2843
 TBranchElement.cxx:2844
 TBranchElement.cxx:2845
 TBranchElement.cxx:2846
 TBranchElement.cxx:2847
 TBranchElement.cxx:2848
 TBranchElement.cxx:2849
 TBranchElement.cxx:2850
 TBranchElement.cxx:2851
 TBranchElement.cxx:2852
 TBranchElement.cxx:2853
 TBranchElement.cxx:2854
 TBranchElement.cxx:2855
 TBranchElement.cxx:2856
 TBranchElement.cxx:2857
 TBranchElement.cxx:2858
 TBranchElement.cxx:2859
 TBranchElement.cxx:2860
 TBranchElement.cxx:2861
 TBranchElement.cxx:2862
 TBranchElement.cxx:2863
 TBranchElement.cxx:2864
 TBranchElement.cxx:2865
 TBranchElement.cxx:2866
 TBranchElement.cxx:2867
 TBranchElement.cxx:2868
 TBranchElement.cxx:2869
 TBranchElement.cxx:2870
 TBranchElement.cxx:2871
 TBranchElement.cxx:2872
 TBranchElement.cxx:2873
 TBranchElement.cxx:2874
 TBranchElement.cxx:2875
 TBranchElement.cxx:2876
 TBranchElement.cxx:2877
 TBranchElement.cxx:2878
 TBranchElement.cxx:2879
 TBranchElement.cxx:2880
 TBranchElement.cxx:2881
 TBranchElement.cxx:2882
 TBranchElement.cxx:2883
 TBranchElement.cxx:2884
 TBranchElement.cxx:2885
 TBranchElement.cxx:2886
 TBranchElement.cxx:2887
 TBranchElement.cxx:2888
 TBranchElement.cxx:2889
 TBranchElement.cxx:2890
 TBranchElement.cxx:2891
 TBranchElement.cxx:2892
 TBranchElement.cxx:2893
 TBranchElement.cxx:2894
 TBranchElement.cxx:2895
 TBranchElement.cxx:2896
 TBranchElement.cxx:2897
 TBranchElement.cxx:2898
 TBranchElement.cxx:2899
 TBranchElement.cxx:2900
 TBranchElement.cxx:2901
 TBranchElement.cxx:2902
 TBranchElement.cxx:2903
 TBranchElement.cxx:2904
 TBranchElement.cxx:2905
 TBranchElement.cxx:2906
 TBranchElement.cxx:2907
 TBranchElement.cxx:2908
 TBranchElement.cxx:2909
 TBranchElement.cxx:2910
 TBranchElement.cxx:2911
 TBranchElement.cxx:2912
 TBranchElement.cxx:2913
 TBranchElement.cxx:2914
 TBranchElement.