ROOT logo
// @(#)root/tree:$Id$
// Author: Rene Brun   12/01/96

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

#include "TBranch.h"

#include "Compression.h"
#include "TBasket.h"
#include "TBranchBrowsable.h"
#include "TBrowser.h"
#include "TClass.h"
#include "TBufferFile.h"
#include "TClonesArray.h"
#include "TFile.h"
#include "TLeaf.h"
#include "TLeafB.h"
#include "TLeafC.h"
#include "TLeafD.h"
#include "TLeafF.h"
#include "TLeafI.h"
#include "TLeafL.h"
#include "TLeafO.h"
#include "TLeafObject.h"
#include "TLeafS.h"
#include "TMessage.h"
#include "TROOT.h"
#include "TSystem.h"
#include "TMath.h"
#include "TTree.h"
#include "TTreeCache.h"
#include "TTreeCacheUnzip.h"
#include "TVirtualMutex.h"
#include "TVirtualPad.h"

#include <cstddef>
#include <string.h>
#include <stdio.h>

Int_t TBranch::fgCount = 0;

#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

//////////////////////////////////////////////////////////////////////////
//                                                                      //
// A TTree is a list of TBranches                                       //
//                                                                      //
// A TBranch supports:                                                  //
//   - The list of TLeaf describing this branch.                        //
//   - The list of TBasket (branch buffers).                            //
//                                                                      //
//       See TBranch structure in TTree.                                //
//                                                                      //
// See also specialized branches:                                       //
//     TBranchObject in case the branch is one object                   //
//     TBranchClones in case the branch is an array of clone objects    //
//////////////////////////////////////////////////////////////////////////

ClassImp(TBranch)

//______________________________________________________________________________
TBranch::TBranch()
: TNamed()
, TAttFill(0, 1001)
, fCompress(0)
, fBasketSize(32000)
, fEntryOffsetLen(1000)
, fWriteBasket(0)
, fEntryNumber(0)
, fOffset(0)
, fMaxBaskets(10)
, fNBaskets(0)
, fSplitLevel(0)
, fNleaves(0)
, fReadBasket(0)
, fReadEntry(-1)
, fFirstBasketEntry(-1)
, fNextBasketEntry(-1)
, fCurrentBasket(0)
, fEntries(0)
, fFirstEntry(0)
, fTotBytes(0)
, fZipBytes(0)
, fBranches()
, fLeaves()
, fBaskets(fMaxBaskets)
, fBasketBytes(0)
, fBasketEntry(0)
, fBasketSeek(0)
, fTree(0)
, fMother(0)
, fParent(0)
, fAddress(0)
, fDirectory(0)
, fFileName("")
, fEntryBuffer(0)
, fBrowsables(0)
, fSkipZip(kFALSE)
, fReadLeaves(&TBranch::ReadLeavesImpl)
, fFillLeaves(&TBranch::FillLeavesImpl)
{
   // Default constructor.  Used for I/O by default.

   SetBit(TBranch::kDoNotUseBufferMap);
}

//______________________________________________________________________________
TBranch::TBranch(TTree *tree, const char* name, void* address, const char* leaflist, Int_t basketsize, Int_t compress)
: TNamed(name, leaflist)
, TAttFill(0, 1001)
, fCompress(compress)
, fBasketSize((basketsize < 100) ? 100 : basketsize)
, fEntryOffsetLen(0)
, fWriteBasket(0)
, fEntryNumber(0)
, fOffset(0)
, fMaxBaskets(10)
, fNBaskets(0)
, fSplitLevel(0)
, fNleaves(0)
, fReadBasket(0)
, fReadEntry(-1)
, fFirstBasketEntry(-1)
, fNextBasketEntry(-1)
, fCurrentBasket(0)
, fEntries(0)
, fFirstEntry(0)
, fTotBytes(0)
, fZipBytes(0)
, fBranches()
, fLeaves()
, fBaskets(fMaxBaskets)
, fBasketBytes(0)
, fBasketEntry(0)
, fBasketSeek(0)
, fTree(tree)
, fMother(0)
, fParent(0)
, fAddress((char*) address)
, fDirectory(fTree->GetDirectory())
, fFileName("")
, fEntryBuffer(0)
, fBrowsables(0)
, fSkipZip(kFALSE)
, fReadLeaves(&TBranch::ReadLeavesImpl)
, fFillLeaves(&TBranch::FillLeavesImpl)
{
   // Create a Branch as a child of a Tree
   //
   //       * address is the address of the first item of a structure
   //         or the address of a pointer to an object (see example in TTree.cxx).
   //       * leaflist is the concatenation of all the variable names and types
   //         separated by a colon character :
   //         The variable name and the variable type are separated by a
   //         slash (/). The variable type must be 1 character. (Characters
   //         after the first are legal and will be appended to the visible
   //         name of the leaf, but have no effect.) If no type is given, the
   //         type of the variable is assumed to be the same as the previous
   //         variable. If the first variable does not have a type, it is
   //         assumed of type F by default. The list of currently supported
   //         types is given below:
   //            - C : a character string terminated by the 0 character
   //            - B : an 8 bit signed integer (Char_t)
   //            - b : an 8 bit unsigned integer (UChar_t)
   //            - S : a 16 bit signed integer (Short_t)
   //            - s : a 16 bit unsigned integer (UShort_t)
   //            - I : a 32 bit signed integer (Int_t)
   //            - i : a 32 bit unsigned integer (UInt_t)
   //            - F : a 32 bit floating point (Float_t)
   //            - D : a 64 bit floating point (Double_t)
   //            - L : a 64 bit signed integer (Long64_t)
   //            - l : a 64 bit unsigned integer (ULong64_t)
   //            - O : [the letter 'o', not a zero] a boolean (Bool_t)
   //
   //         Arrays of values are supported with the following syntax:
   //         If leaf name has the form var[nelem], where nelem is alphanumeric, then
   //            if nelem is a leaf name, it is used as the variable size of the array, 
   //            otherwise return 0.
   //            The leaf referred to by nelem **MUST** be an int (/I), 
   //         If leaf name has the form var[nelem], where nelem is a non-negative integers, then
   //            it is used as the fixed size of the array.
   //         If leaf name has the form of a multi dimension array (e.g. var[nelem][nelem2])
   //            where nelem and nelem2 are non-negative integers) then
   //            it is used as a 2 dimensional array of fixed size.
   //         Any of other form is not supported.
   //
   //    Note that the TTree will assume that all the item are contiguous in memory.
   //    On some platform, this is not always true of the member of a struct or a class,
   //    due to padding and alignment.  Sorting your data member in order of decreasing
   //    sizeof usually leads to their being contiguous in memory.
   //
   //       * bufsize is the buffer size in bytes for this branch
   //         The default value is 32000 bytes and should be ok for most cases.
   //         You can specify a larger value (e.g. 256000) if your Tree is not split
   //         and each entry is large (Megabytes)
   //         A small value for bufsize is optimum if you intend to access
   //         the entries in the Tree randomly and your Tree is in split mode.
   //
   //   See an example of a Branch definition in the TTree constructor.
   //
   //   Note that in case the data type is an object, this branch can contain
   //   only this object.
   //
   //    Note that this function is invoked by TTree::Branch

   Init(name,leaflist,compress);
}

//______________________________________________________________________________
TBranch::TBranch(TBranch *parent, const char* name, void* address, const char* leaflist, Int_t basketsize, Int_t compress)
: TNamed(name, leaflist)
, TAttFill(0, 1001)
, fCompress(compress)
, fBasketSize((basketsize < 100) ? 100 : basketsize)
, fEntryOffsetLen(0)
, fWriteBasket(0)
, fEntryNumber(0)
, fOffset(0)
, fMaxBaskets(10)
, fNBaskets(0)
, fSplitLevel(0)
, fNleaves(0)
, fReadBasket(0)
, fReadEntry(-1)
, fFirstBasketEntry(-1)
, fNextBasketEntry(-1)
, fCurrentBasket(0)
, fEntries(0)
, fFirstEntry(0)
, fTotBytes(0)
, fZipBytes(0)
, fBranches()
, fLeaves()
, fBaskets(fMaxBaskets)
, fBasketBytes(0)
, fBasketEntry(0)
, fBasketSeek(0)
, fTree(parent ? parent->GetTree() : 0)
, fMother(parent ? parent->GetMother() : 0)
, fParent(parent)
, fAddress((char*) address)
, fDirectory(fTree ? fTree->GetDirectory() : 0)
, fFileName("")
, fEntryBuffer(0)
, fBrowsables(0)
, fSkipZip(kFALSE)
, fReadLeaves(&TBranch::ReadLeavesImpl)
, fFillLeaves(&TBranch::FillLeavesImpl)
{
   // Create a Branch as a child of another Branch
   //
   // See documentation for 
   // TBranch::TBranch(TTree *, const char *, void *, const char *, Int_t, Int_t) 

   Init(name,leaflist,compress);
}

void TBranch::Init(const char* name, const char* leaflist, Int_t compress)
{
   // Initialization routine called from the constructor.  This should NOT be made virtual.

   SetBit(TBranch::kDoNotUseBufferMap);
   if ((compress == -1) && fTree->GetDirectory()) {
      TFile* bfile = fTree->GetDirectory()->GetFile();
      if (bfile) {
         fCompress = bfile->GetCompressionSettings();
      }
   }

   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;
   }

   //
   // Decode the leaflist (search for : as separator).
   //

   char* nameBegin = const_cast<char*>(leaflist);
   Int_t offset = 0;
   // FIXME: Make these string streams instead.
   char* leafname = new char[640];
   char* leaftype = new char[320];
   // Note: The default leaf type is a float.
   strlcpy(leaftype, "F",320);
   char* pos = const_cast<char*>(leaflist);
   const char* leaflistEnd = leaflist + strlen(leaflist);
   for (; pos <= leaflistEnd; ++pos) {
      // -- Scan leaf specification and create leaves.
      if ((*pos == ':') || (*pos == 0)) {
         // -- Reached end of a leaf spec, create a leaf.
         Int_t lenName = pos - nameBegin;
         char* ctype = 0;
         if (lenName) {
            strncpy(leafname, nameBegin, lenName);
            leafname[lenName] = 0;
            ctype = strstr(leafname, "/");
            if (ctype) {
               *ctype = 0;
               strlcpy(leaftype, ctype + 1,320);
            }
         }
         if (lenName == 0 || ctype == leafname) {
            Warning("TBranch","No name was given to the leaf number '%d' in the leaflist of the branch '%s'.",fNleaves,name);
            snprintf(leafname,640,"__noname%d",fNleaves);
         }
         TLeaf* leaf = 0;
         if (*leaftype == 'C') {
            leaf = new TLeafC(this, leafname, leaftype);
         } else if (*leaftype == 'O') {
            leaf = new TLeafO(this, leafname, leaftype);
         } else if (*leaftype == 'B') {
            leaf = new TLeafB(this, leafname, leaftype);
         } else if (*leaftype == 'b') {
            leaf = new TLeafB(this, leafname, leaftype);
            leaf->SetUnsigned();
         } else if (*leaftype == 'S') {
            leaf = new TLeafS(this, leafname, leaftype);
         } else if (*leaftype == 's') {
            leaf = new TLeafS(this, leafname, leaftype);
            leaf->SetUnsigned();
         } else if (*leaftype == 'I') {
            leaf = new TLeafI(this, leafname, leaftype);
         } else if (*leaftype == 'i') {
            leaf = new TLeafI(this, leafname, leaftype);
            leaf->SetUnsigned();
         } else if (*leaftype == 'F') {
            leaf = new TLeafF(this, leafname, leaftype);
         } else if (*leaftype == 'f') {
            leaf = new TLeafF(this, leafname, leaftype);
         } else if (*leaftype == 'L') {
            leaf = new TLeafL(this, leafname, leaftype);
         } else if (*leaftype == 'l') {
            leaf = new TLeafL(this, leafname, leaftype);
            leaf->SetUnsigned();
         } else if (*leaftype == 'D') {
            leaf = new TLeafD(this, leafname, leaftype);
         } else if (*leaftype == 'd') {
            leaf = new TLeafD(this, leafname, leaftype);
         }
         if (!leaf) {
            Error("TLeaf", "Illegal data type for %s/%s", name, leaflist);
            delete[] leaftype;
            delete [] leafname;
            MakeZombie();
            return;
         }
         if (leaf->IsZombie()) {
            delete leaf;
            leaf = 0;
            Error("TBranch", "Illegal leaf: %s/%s", name, leaflist);
            delete [] leafname;
            delete[] leaftype;
            MakeZombie();
            return;
         }
         leaf->SetBranch(this);
         leaf->SetAddress((char*) (fAddress + offset));
         leaf->SetOffset(offset);
         if (leaf->GetLeafCount()) {
            // -- Leaf is a varying length array, we need an offset array.
            fEntryOffsetLen = 1000;
         }
         if (leaf->InheritsFrom(TLeafC::Class())) {
            // -- Leaf is a character string, we need an offset array.
            fEntryOffsetLen = 1000;
         }
         ++fNleaves;
         fLeaves.Add(leaf);
         fTree->GetListOfLeaves()->Add(leaf);
         if (*pos == 0) {
            // -- We reached the end of the leaf specification.
            break;
         }
         nameBegin = pos + 1;
         offset += leaf->GetLenType() * leaf->GetLen();
      }
   }
   delete[] leafname;
   leafname = 0;
   delete[] leaftype;
   leaftype = 0;

}

//______________________________________________________________________________
TBranch::~TBranch()
{
   // Destructor.

   delete fBrowsables;
   fBrowsables = 0;

   // Note: We do *not* have ownership of the buffer.
   fEntryBuffer = 0;

   delete [] fBasketSeek;
   fBasketSeek  = 0;

   delete [] fBasketEntry;
   fBasketEntry = 0;

   delete [] fBasketBytes;
   fBasketBytes = 0;

   fBaskets.Delete();
   fNBaskets = 0;
   fCurrentBasket = 0;
   fFirstBasketEntry = -1;
   fNextBasketEntry = -1;

   // Remove our leaves from our tree's list of leaves.
   if (fTree) {
      TObjArray* lst = fTree->GetListOfLeaves();
      if (lst && lst->GetLast()!=-1) {
         lst->RemoveAll(&fLeaves);
      }
   }
   // And delete our leaves.
   fLeaves.Delete();

   fBranches.Delete();

   // If we are in a directory and that directory is not the same
   // directory that our tree is in, then try to find an open file
   // with the name fFileName.  If we find one, delete that file.
   // We are attempting to close any alternate file which we have
   // been directed to write our baskets to.
   // FIXME: We make no attempt to check if someone else might be
   //        using this file.  This is very user hostile.  A violation
   //        of the principle of least surprises.
   //
   // Warning. Must use FindObject by name instead of fDirectory->GetFile()
   // because two branches may point to the same file and the file
   // may have already been deleted in the previous branch.
   if (fDirectory && (!fTree || fDirectory != fTree->GetDirectory())) {
      TString bFileName( GetRealFileName() );

      R__LOCKGUARD2(gROOTMutex);
      TFile* file = (TFile*)gROOT->GetListOfFiles()->FindObject(bFileName);
      if (file){
         file->Close();
         delete file;
         file = 0;
      }
   }

   fTree = 0;
   fDirectory = 0;
}

//______________________________________________________________________________
void TBranch::AddBasket(TBasket& b, Bool_t ondisk, Long64_t startEntry)
{
   // Add the basket to this branch.

   // Warning: if the basket are not 'flushed/copied' in the same
   // order as they were created, this will induce a slow down in
   // the insert (since we'll need to move all the record that are
   // entere 'too early').
   // Warning we also assume that the __current__ write basket is
   // not present (aka has been removed).

   TBasket *basket = &b;

   basket->SetBranch(this);

   if (fWriteBasket >= fMaxBaskets) {
      ExpandBasketArrays();
   }
   Int_t where = fWriteBasket;

   if (where && startEntry < fBasketEntry[where-1]) {
      // Need to find the right location and move the possible baskets

      if (!ondisk) {
         Warning("AddBasket","The assumption that out-of-order basket only comes from disk based ntuple is false.");
      }

      if (startEntry < fBasketEntry[0]) {
         where = 0;
      } else {
         for(Int_t i=fWriteBasket-1; i>=0; --i) {
            if (fBasketEntry[i] < startEntry) {
               where = i+1;
               break;
            } else if (fBasketEntry[i] == startEntry) {
               Error("AddBasket","An out-of-order basket matches the entry number of an existing basket.");
            }
         }
      }

      if (where < fWriteBasket) {
         // We shall move the content of the array
         for (Int_t j=fWriteBasket; j > where; --j) {
            fBasketEntry[j] = fBasketEntry[j-1];
            fBasketBytes[j] = fBasketBytes[j-1];
            fBasketSeek[j]  = fBasketSeek[j-1];
         }
      }
   }
   fBasketEntry[where] = startEntry;

   if (ondisk) {
      fBasketBytes[where] = basket->GetNbytes();  // not for in mem
      fBasketSeek[where] = basket->GetSeekKey();  // not for in mem
      fBaskets.AddAtAndExpand(0,fWriteBasket);
      ++fWriteBasket;
   } else {
      ++fNBaskets;
      fBaskets.AddAtAndExpand(basket,fWriteBasket);
      fTree->IncrementTotalBuffers(basket->GetBufferSize());
   }

   fEntries += basket->GetNevBuf();
   fEntryNumber += basket->GetNevBuf();
   if (ondisk) {
      fTotBytes += basket->GetObjlen() + basket->GetKeylen() ;
      fZipBytes += basket->GetNbytes();
      fTree->AddTotBytes(basket->GetObjlen() + basket->GetKeylen());
      fTree->AddZipBytes(basket->GetNbytes());
   }
}

//______________________________________________________________________________
void TBranch::AddLastBasket(Long64_t startEntry)
{
   // Add the start entry of the write basket (not yet created)

   if (fWriteBasket >= fMaxBaskets) {
      ExpandBasketArrays();
   }
   Int_t where = fWriteBasket;

   if (where && startEntry < fBasketEntry[where-1]) {
      // Need to find the right location and move the possible baskets

      Fatal("AddBasket","The last basket must have the highest entry number (%s/%lld/%d).",GetName(),startEntry,fWriteBasket);

   }
   fBasketEntry[where] = startEntry;
   fBaskets.AddAtAndExpand(0,fWriteBasket);
}

//______________________________________________________________________________
void TBranch::Browse(TBrowser* b)
{
   // Browser interface.

   if (fNleaves > 1) {
      fLeaves.Browse(b);
   } else {
      // Get the name and strip any extra brackets
      // in order to get the full arrays.
      TString name = GetName();
      Int_t pos = name.First('[');
      if (pos!=kNPOS) name.Remove(pos);

      GetTree()->Draw(name, "", b ? b->GetDrawOption() : "");
      if (gPad) gPad->Update();
   }
}

 //______________________________________________________________________________
void TBranch::DeleteBaskets(Option_t* option)
{
   // Loop on all branch baskets. If the file where branch buffers reside is
   // writable, free the disk space associated to the baskets of the branch,
   // then call Reset(). If the option contains "all", delete also the baskets
   // for the subbranches.
   // The branch is reset.
   // NOTE that this function must be used with extreme care. Deleting branch baskets
   // fragments the file and may introduce inefficiencies when adding new entries
   // in the Tree or later on when reading the Tree.

   TString opt = option;
   opt.ToLower();
   TFile *file = GetFile(0);

   if(fDirectory && (fDirectory != gROOT) && fDirectory->IsWritable()) {
      for(Int_t i=0; i<fWriteBasket; i++) {
         if (fBasketSeek[i]) file->MakeFree(fBasketSeek[i],fBasketSeek[i]+fBasketBytes[i]-1);
      }
   }

   // process subbranches
   if (opt.Contains("all")) {
      TObjArray *lb = GetListOfBranches();
      Int_t nb = lb->GetEntriesFast();
      for (Int_t j = 0; j < nb; j++) {
         TBranch* branch = (TBranch*) lb->UncheckedAt(j);
         if (branch) branch->DeleteBaskets("all");
      }
   }
   DropBaskets("all");
   Reset();
}

//______________________________________________________________________________
void TBranch::DropBaskets(Option_t* options)
{
   // Loop on all branch baskets. Drop all baskets from memory except readbasket.
   // If the option contains "all", drop all baskets including
   // read- and write-baskets (unless they are not stored individually on disk).
   // The option "all" also lead to DropBaskets being called on the sub-branches.

   Bool_t all = kFALSE;
   if (options && options[0]) {
      TString opt = options;
      opt.ToLower();
      if (opt.Contains("all")) all = kTRUE;
   }

   TBasket *basket;
   Int_t nbaskets = fBaskets.GetEntriesFast();

   if ( (fNBaskets>1) || all ) {
      //slow case
      for (Int_t i=0;i<nbaskets;i++) {
         basket = (TBasket*)fBaskets.UncheckedAt(i);
         if (!basket) continue;
         if ((i == fReadBasket || i == fWriteBasket) && !all) continue;
         // if the basket is not yet on file but already has event in it
         // we must continue to avoid dropping the basket (and thus losing data)
         if (fBasketBytes[i]==0 && basket->GetNevBuf() > 0) continue; 
         basket->DropBuffers();
         --fNBaskets;
         fBaskets.RemoveAt(i);
         if (basket == fCurrentBasket) {
            fCurrentBasket    = 0;
            fFirstBasketEntry = -1;
            fNextBasketEntry  = -1;
         }
         delete basket;
      }

      // process subbranches
      if (all) {
         TObjArray *lb = GetListOfBranches();
         Int_t nb = lb->GetEntriesFast();
         for (Int_t j = 0; j < nb; j++) {
            TBranch* branch = (TBranch*) lb->UncheckedAt(j);
            if (!branch) continue;
            branch->DropBaskets("all");
         }
      }
   } else {
      //fast case
      if (nbaskets > 0) {
         Int_t i = fBaskets.GetLast();
         basket = (TBasket*)fBaskets.UncheckedAt(i);
         if (basket && fBasketBytes[i]!=0) {
            basket->DropBuffers();
            if (basket == fCurrentBasket) {
               fCurrentBasket    = 0;
               fFirstBasketEntry = -1;
               fNextBasketEntry  = -1;
            }            
            delete basket;
            fBaskets.AddAt(0,i);
            fBaskets.SetLast(-1);
            fNBaskets = 0;
         }
      }
   }

}

//______________________________________________________________________________
void TBranch::ExpandBasketArrays()
{
   // Increase BasketEntry buffer of a minimum of 10 locations
   // and a maximum of 50 per cent of current size.

   Int_t newsize = TMath::Max(10,Int_t(1.5*fMaxBaskets));
   fBasketBytes  = TStorage::ReAllocInt(fBasketBytes, newsize, fMaxBaskets);
   fBasketEntry  = (Long64_t*)TStorage::ReAlloc(fBasketEntry,
                                                newsize*sizeof(Long64_t),fMaxBaskets*sizeof(Long64_t));
   fBasketSeek   = (Long64_t*)TStorage::ReAlloc(fBasketSeek,
                                                newsize*sizeof(Long64_t),fMaxBaskets*sizeof(Long64_t));

   fMaxBaskets   = newsize;

   fBaskets.Expand(newsize);

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

//______________________________________________________________________________
Int_t TBranch::Fill()
{
   // Loop on all leaves of this branch to fill Basket buffer.
   //
   // The function returns the number of bytes committed to the memory basket.
   // 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.
   //

   if (TestBit(kDoNotProcess)) {
      return 0;
   }

   TBasket* basket = GetBasket(fWriteBasket);
   if (!basket) {
      basket = fTree->CreateBasket(this); //  create a new basket
      if (!basket) return 0;
      ++fNBaskets;
      fBaskets.AddAtAndExpand(basket,fWriteBasket);
   }
   TBuffer* buf = basket->GetBufferRef();

   // Fill basket buffer.

   Int_t nsize  = 0;

   if (buf->IsReading()) {
      basket->SetWriteMode();
   }

   buf->ResetMap();

   Int_t lnew = 0;
   Int_t nbytes = 0;

   if (fEntryBuffer) {
      nbytes = FillEntryBuffer(basket,buf,lnew);
   } else {
      Int_t lold = buf->Length();
      basket->Update(lold);
      ++fEntries;
      ++fEntryNumber;
      (this->*fFillLeaves)(*buf);
      if (buf->GetMapCount()) {
         // The map is used.
         ResetBit(TBranch::kDoNotUseBufferMap);
      }
      lnew = buf->Length();
      nbytes = lnew - lold;
   }

   if (fEntryOffsetLen) {
      Int_t nevbuf = basket->GetNevBuf();
      // Total size in bytes of EntryOffset table.
      nsize = nevbuf * sizeof(Int_t);
   } else {
      if (!basket->GetNevBufSize()) {
         basket->SetNevBufSize(nbytes);
      }
   }

   // Should we create a new basket?
   // fSkipZip force one entry per buffer (old stuff still maintained for CDF)
   // Transfer full compressed buffer only

   if ((fSkipZip && (lnew >= TBuffer::kMinimalSize)) || (buf->TestBit(TBufferFile::kNotDecompressed)) || ((lnew + (2 * nsize) + nbytes) >= fBasketSize)) {
      if (fTree->TestBit(TTree::kCircular)) {
         return nbytes;
      }
      Int_t nout = WriteBasket(basket,fWriteBasket);
      return (nout >= 0) ? nbytes : -1;
   }
   return nbytes;
}

//______________________________________________________________________________
Int_t TBranch::FillEntryBuffer(TBasket* basket, TBuffer* buf, Int_t& lnew) 
{
   // Copy the data from fEntryBuffer into the current basket.

   Int_t nbytes = 0;
   Int_t objectStart = 0;
   Int_t last = 0;
   Int_t lold = buf->Length();

   // Handle the special case of fEntryBuffer != 0
   if (fEntryBuffer->IsA() == TMessage::Class()) {
      objectStart = 8;
   }
   if (fEntryBuffer->TestBit(TBufferFile::kNotDecompressed)) {
      // The buffer given as input has not been decompressed.
      if (basket->GetNevBuf()) {
         // If the basket already contains entry we need to close it
         // out. (This is because we can only transfer full compressed
         // buffer)
         WriteBasket(basket,fWriteBasket);
         // And restart from scratch
         return Fill();
      }
      Int_t startpos = fEntryBuffer->Length();
      fEntryBuffer->SetBufferOffset(0);
      static TBasket toread_fLast;
      fEntryBuffer->SetReadMode();
      toread_fLast.Streamer(*fEntryBuffer);
      fEntryBuffer->SetWriteMode();
      last = toread_fLast.GetLast();
      // last now contains the decompressed number of bytes.
      fEntryBuffer->SetBufferOffset(startpos);
      buf->SetBufferOffset(0);
      buf->SetBit(TBufferFile::kNotDecompressed);
      basket->Update(lold);
   } else {
      // We are required to copy starting at the version number (so not
      // including the class name.
      // See if byte count is here, if not it class still be a newClass
      const UInt_t kNewClassTag = 0xFFFFFFFF;
      const UInt_t kByteCountMask = 0x40000000;  // OR the byte count with this
      UInt_t tag = 0;
      UInt_t startpos = fEntryBuffer->Length();
      fEntryBuffer->SetBufferOffset(objectStart);
      *fEntryBuffer >> tag;
      if (tag & kByteCountMask) {
         *fEntryBuffer >> tag;
      }
      if (tag == kNewClassTag) {
         UInt_t maxsize = 256;
         char* s = new char[maxsize];
         Int_t name_start = fEntryBuffer->Length();
         fEntryBuffer->ReadString(s, maxsize); // Reads at most maxsize - 1 characters, plus null at end.
         while (strlen(s) == (maxsize - 1)) {
            // The classname is too large, try again with a large buffer.
            fEntryBuffer->SetBufferOffset(name_start);
            maxsize *= 2;
            delete[] s;
            s = new char[maxsize];
            fEntryBuffer->ReadString(s, maxsize); // Reads at most maxsize - 1 characters, plus null at end
         }
      } else {
         fEntryBuffer->SetBufferOffset(objectStart);
      }
      objectStart = fEntryBuffer->Length();
      fEntryBuffer->SetBufferOffset(startpos);
      basket->Update(lold, objectStart - fEntryBuffer->GetBufferDisplacement());
   }
   fEntries++;
   fEntryNumber++;
   UInt_t len = 0;
   UInt_t startpos = fEntryBuffer->Length();
   if (startpos > UInt_t(objectStart)) {
      // We assume this buffer have just been directly filled
      // the current position in the buffer indicates the end of the object!
      len = fEntryBuffer->Length() - objectStart;
   } else {
      // The buffer have been acquired either via TSocket or via
      // TBuffer::SetBuffer(newloc,newsize)
      // Only the actual size of the memory buffer gives us an hint about where
      // the object ends.
      len = fEntryBuffer->BufferSize() - objectStart;
   }
   buf->WriteBuf(fEntryBuffer->Buffer() + objectStart, len);
   if (fEntryBuffer->TestBit(TBufferFile::kNotDecompressed)) {
      // The original buffer came pre-compressed and thus the buffer Length
      // does not really show the really object size
      // lnew = nbytes = basket->GetLast();
      nbytes = last;
      lnew = last;
   } else {
      lnew = buf->Length();
      nbytes = lnew - lold;
   }

   return nbytes;
}

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

   // We allow the user to pass only the last dotted component of the name.
   std::string longnm;
   longnm.reserve(fName.Length()+strlen(name)+3);
   longnm = fName.Data();
   if (longnm[longnm.length()-1]==']') {
      std::size_t dim = longnm.find_first_of("[");
      if (dim != std::string::npos) {
         longnm.erase(dim);
      }
   }
   if (longnm[longnm.length()-1] != '.') {
      longnm += '.';
   }
   longnm += name;
   UInt_t namelen = strlen(name);

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

      const char *brname = branch->fName.Data();
      UInt_t brlen = branch->fName.Length();
      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 == (size_t)longnm.length()
          && strncmp(longnm.c_str(),brname,brlen) == 0) {
         return branch;
      }
   }
   return 0;
}

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

   TString leafname;
   TString leaftitle;
   TString longname;
   TString longtitle;

   // We allow the user to pass only the last dotted component of the name.
   TIter next(GetListOfLeaves());
   TLeaf* leaf = 0;
   while ((leaf = (TLeaf*) next())) {
      leafname = leaf->GetName();
      Ssiz_t dim = leafname.First('[');
      if (dim >= 0) leafname.Remove(dim);

      if (leafname == searchname) return leaf;

      // The leaf element contains the branch name in its name, let's use the title.
      leaftitle = leaf->GetTitle();
      dim = leaftitle.First('[');
      if (dim >= 0) leaftitle.Remove(dim);

      if (leaftitle == searchname) return leaf;

      TBranch* branch = leaf->GetBranch();
      if (branch) {
         longname.Form("%s.%s",branch->GetName(),leafname.Data());
         dim = longname.First('[');
         if (dim>=0) longname.Remove(dim);
         if (longname == searchname) return leaf;

         // The leaf element contains the branch name in its name.
         longname.Form("%s.%s",branch->GetName(),searchname);
         if (longname==leafname) return leaf;

         longtitle.Form("%s.%s",branch->GetName(),leaftitle.Data());
         dim = longtitle.First('[');
         if (dim>=0) longtitle.Remove(dim);
         if (longtitle == searchname) return leaf;

         // The following is for the case where the branch is only
         // a sub-branch.  Since we do not see it through
         // TTree::GetListOfBranches, we need to see it indirectly.
         // This is the less sturdy part of this search ... it may
         // need refining ...
         if (strstr(searchname, ".") && !strcmp(searchname, branch->GetName())) return leaf;
      }
   }
   return 0;
}


//______________________________________________________________________________
Int_t TBranch::FlushBaskets()
{
   // Flush to disk all the baskets of this branch and any of subbranches.
   // Return the number of bytes written or -1 in case of write error.

   UInt_t nerror = 0;
   Int_t nbytes = 0;

   Int_t maxbasket = fWriteBasket + 1;
   // The following protection is not necessary since we should always
   // have fWriteBasket < fBasket.GetSize()
   //if (fBaskets.GetSize() < maxbasket) {
   //   maxbasket = fBaskets.GetSize();
   //}
   for(Int_t i=0; i != maxbasket; ++i) {
      if (fBaskets.UncheckedAt(i)) {
         Int_t nwrite = FlushOneBasket(i);
         if (nwrite<0) {
            ++nerror;
         } else {
            nbytes += nwrite;
         }
      }
   }
   Int_t len = fBranches.GetEntriesFast();
   for (Int_t i = 0; i < len; ++i) {
      TBranch* branch = (TBranch*) fBranches.UncheckedAt(i);
      if (!branch) {
         continue;
      }
      Int_t nwrite = branch->FlushBaskets();
      if (nwrite<0) {
         ++nerror;
      } else {
         nbytes += nwrite;
      }
   }
   if (nerror) {
      return -1;
   } else {
      return nbytes;
   }
}

//______________________________________________________________________________
Int_t TBranch::FlushOneBasket(UInt_t ibasket)
{
   // If we have a write basket in memory and it contains some entries and
   // has not yet been written to disk, we write it and delete it from memory.
   // Return the number of bytes written;

   Int_t nbytes = 0;
   if (fDirectory && fBaskets.GetEntries()) {
      TBasket *basket = (TBasket*)fBaskets.UncheckedAt(ibasket);

      if (basket) {
         if (basket->GetNevBuf()
             && fBasketSeek[ibasket]==0) {
            // If the basket already contains entry we need to close it out.
            // (This is because we can only transfer full compressed buffer)

            if (basket->GetBufferRef()->IsReading()) {
               basket->SetWriteMode();
            }
            nbytes = WriteBasket(basket,ibasket);

         } else {
            // If the basket is empty or has already been written.
            if ((Int_t)ibasket==fWriteBasket) {
               // Nothing to do.
            } else {
               basket->DropBuffers();
               if (basket == fCurrentBasket) {
                  fCurrentBasket    = 0;
                  fFirstBasketEntry = -1;
                  fNextBasketEntry  = -1;
               }               
               delete basket;
               --fNBaskets;
               fBaskets[ibasket] = 0;
            }
         }
      }
   }
   return nbytes;
}

//______________________________________________________________________________
TBasket* TBranch::GetBasket(Int_t basketnumber)
{
   //         Return pointer to basket basketnumber in this Branch

   static Int_t nerrors = 0;

      // reference to an existing basket in memory ?
   if (basketnumber <0 || basketnumber > fWriteBasket) return 0;
   TBasket *basket = (TBasket*)fBaskets.UncheckedAt(basketnumber);
   if (basket) return basket;
   if (basketnumber == fWriteBasket) return 0;

   // create/decode basket parameters from buffer
   TFile *file = GetFile(0);
   if (file == 0) {
      return 0;
   }
   basket = GetFreshBasket();

   // fSkipZip is old stuff still maintained for CDF
   if (fSkipZip) basket->SetBit(TBufferFile::kNotDecompressed);
   if (fBasketBytes[basketnumber] == 0) {
      fBasketBytes[basketnumber] = basket->ReadBasketBytes(fBasketSeek[basketnumber],file);
   }
   //add branch to cache (if any)
   TFileCacheRead *pf = file->GetCacheRead(fTree);
   if (pf){
      if (pf->IsLearning()) pf->AddBranch(this);
      if (fSkipZip) pf->SetSkipZip();
   }

   //now read basket
   Int_t badread = basket->ReadBasketBuffers(fBasketSeek[basketnumber],fBasketBytes[basketnumber],file);
   if (badread || basket->GetSeekKey() != fBasketSeek[basketnumber]) {
      nerrors++;
      if (nerrors > 10) return 0;
      if (nerrors == 10) {
         printf(" file probably overwritten: stopping reporting error messages\n");
         if (fBasketSeek[basketnumber] > 2000000000) {
            printf("===>File is more than 2 Gigabytes\n");
            return 0;
         }
         if (fBasketSeek[basketnumber] > 1000000000) {
            printf("===>Your file is may be bigger than the maximum file size allowed on your system\n");
            printf("    Check your AFS maximum file size limit for example\n");
            return 0;
         }
      }
      Error("GetBasket","File: %s at byte:%lld, branch:%s, entry:%lld, badread=%d, nerrors=%d, basketnumber=%d",file->GetName(),basket->GetSeekKey(),GetName(),fReadEntry,badread,nerrors,basketnumber);
      return 0;
   }

   ++fNBaskets;
   fBaskets.AddAt(basket,basketnumber);
   return basket;
}

//______________________________________________________________________________
Long64_t TBranch::GetBasketSeek(Int_t basketnumber) const
{
   //         Return address of basket in the file

   if (basketnumber <0 || basketnumber > fWriteBasket) return 0;
   return fBasketSeek[basketnumber];
}

//______________________________________________________________________________
TList* TBranch::GetBrowsables() {
   // Returns (and, if 0, creates) browsable objects for this branch
   // See TVirtualBranchBrowsable::FillListOfBrowsables.
   if (fBrowsables) return fBrowsables;
   fBrowsables=new TList();
   TVirtualBranchBrowsable::FillListOfBrowsables(*fBrowsables, this);
   return fBrowsables;
}

//______________________________________________________________________________
const char * TBranch::GetClassName() const 
{
   // Return the name of the user class whose content is stored in this branch,
   // if any.  If this branch was created using the 'leaflist' technique, this
   // function returns an empty string.

   return "";
}

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

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

//______________________________________________________________________________
Int_t TBranch::GetEntry(Long64_t entry, Int_t getall)
{
   // Read all leaves of entry and return total number of bytes read.
   //
   // The input argument "entry" is the entry number in the current tree.
   // In case of a TChain, the entry number in the current Tree must be found
   // before calling this function. For example:
   //
   //     TChain* chain = ...;
   //     Long64_t localEntry = chain->LoadTree(entry);
   //     branch->GetEntry(localEntry);
   //
   // The function returns the number of bytes read from the input buffer.
   // If entry does not exist, the function returns 0.
   // If an I/O error occurs, the function returns -1.
   //
   // See IMPORTANT REMARKS in TTree::GetEntry.
   //

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

   Bool_t enabled = !TestBit(kDoNotProcess) || getall;
   TBasket *basket; // will be initialized in the if/then clauses.
   Long64_t first;
   if (R__likely(enabled && fFirstBasketEntry <= entry && entry < fNextBasketEntry)) {
      // We have found the basket containing this entry.
      // make sure basket buffers are in memory.
      basket = fCurrentBasket;
      first = fFirstBasketEntry;
   } else {
      if (!enabled) {
         return 0;
      }
      if ((entry < fFirstEntry) || (entry >= fEntryNumber)) {
         return 0;
      }
      first = fFirstBasketEntry;
      Long64_t last = fNextBasketEntry - 1;
      // Are we still in the same ReadBasket?
      if ((entry < first) || (entry > last)) {
         fReadBasket = TMath::BinarySearch(fWriteBasket + 1, fBasketEntry, entry);
         if (fReadBasket < 0) {
            fNextBasketEntry = -1;
            Error("In the branch %s, no basket contains the entry %d\n", GetName(), entry);
            return -1;
         }
         if (fReadBasket == fWriteBasket) {
            fNextBasketEntry = fEntryNumber;
         } else {
            fNextBasketEntry = fBasketEntry[fReadBasket+1];
         }
         first = fFirstBasketEntry = fBasketEntry[fReadBasket];
      }
      // We have found the basket containing this entry.
      // make sure basket buffers are in memory.
      basket = (TBasket*) fBaskets.UncheckedAt(fReadBasket);
      if (!basket) {
         basket = GetBasket(fReadBasket);
         if (!basket) {
            fCurrentBasket = 0;
            fFirstBasketEntry = -1; 
            fNextBasketEntry = -1;
            return -1;
         }
      }
      fCurrentBasket = basket;
   }
   basket->PrepareBasket(entry);
   TBuffer* buf = basket->GetBufferRef();

   // This test necessary to read very old Root files (NvE).
   if (R__unlikely(!buf)) {
      TFile* file = GetFile(0);
      if (!file) return -1;
      basket->ReadBasketBuffers(fBasketSeek[fReadBasket], fBasketBytes[fReadBasket], file);
      buf = basket->GetBufferRef();
   }
   // Set entry offset in buffer.
   if (!TestBit(kDoNotUseBufferMap)) {
      buf->ResetMap();
   }
   if (R__unlikely(!buf->IsReading())) {
      basket->SetReadMode();
   }
   Int_t* entryOffset = basket->GetEntryOffset();
   Int_t bufbegin = 0;
   if (entryOffset) {
      bufbegin = entryOffset[entry-first];
      buf->SetBufferOffset(bufbegin);
      Int_t* displacement = basket->GetDisplacement();
      if (R__unlikely(displacement)) {
         buf->SetBufferDisplacement(displacement[entry-first]);
      }
   } else {
      bufbegin = basket->GetKeylen() + ((entry-first) * basket->GetNevBufSize());
      buf->SetBufferOffset(bufbegin);
   }

   // Int_t bufbegin = buf->Length();
   (this->*fReadLeaves)(*buf);
   return buf->Length() - bufbegin;
}

//______________________________________________________________________________
Int_t TBranch::GetEntryExport(Long64_t entry, Int_t /*getall*/, TClonesArray* li, Int_t nentries)
{
   // Read all leaves of an entry and export buffers to real objects in a TClonesArray list.
   //
   // Returns total number of bytes read.

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

   if (TestBit(kDoNotProcess)) {
      return 0;
   }
   if ((entry < 0) || (entry >= fEntryNumber)) {
      return 0;
   }
   Int_t nbytes = 0;
   Long64_t first  = fFirstBasketEntry;
   Long64_t last = fNextBasketEntry - 1;
   // Are we still in the same ReadBasket?
   if ((entry < first) || (entry > last)) {
      fReadBasket = TMath::BinarySearch(fWriteBasket + 1, fBasketEntry, entry);
      if (fReadBasket < 0) {
         fNextBasketEntry = -1;
         Error("In the branch %s, no basket contains the entry %d\n", GetName(), entry);
         return -1;
      }
      if (fReadBasket == fWriteBasket) {
         fNextBasketEntry = fEntryNumber;
      } else {
         fNextBasketEntry = fBasketEntry[fReadBasket+1];
      }
      fFirstBasketEntry = first = fBasketEntry[fReadBasket];
   }

   // We have found the basket containing this entry.
   // Make sure basket buffers are in memory.
   TBasket* basket = GetBasket(fReadBasket);
   fCurrentBasket = basket;
   if (!basket) {
      fFirstBasketEntry = -1; 
      fNextBasketEntry = -1;
      return 0;
   }
   TBuffer* buf = basket->GetBufferRef();
   // Set entry offset in buffer and read data from all leaves.
   if (!TestBit(kDoNotUseBufferMap)) {
      buf->ResetMap();
   }
   if (R__unlikely(!buf->IsReading())) {
      basket->SetReadMode();
   } 
   Int_t* entryOffset = basket->GetEntryOffset();
   Int_t bufbegin = 0;
   if (entryOffset) {
      bufbegin = entryOffset[entry-first];
      buf->SetBufferOffset(bufbegin);
      Int_t* displacement = basket->GetDisplacement();
      if (R__unlikely(displacement)) {
         buf->SetBufferDisplacement(displacement[entry-first]);
      }
   } else {
      bufbegin = basket->GetKeylen() + ((entry-first) * basket->GetNevBufSize());
      buf->SetBufferOffset(bufbegin);
   }
   TLeaf* leaf = (TLeaf*) fLeaves.UncheckedAt(0);
   leaf->ReadBasketExport(*buf, li, nentries);
   nbytes = buf->Length() - bufbegin;
   return nbytes;
}

//______________________________________________________________________________
Int_t TBranch::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;
   TLeaf* l = (TLeaf*) GetListOfLeaves()->At(0);
   if (l) {
      expectedType = (EDataType) gROOT->GetType(l->GetTypeName())->GetType();
      return 0;
   } else {
      Error("GetExpectedType", "Did not find any leaves in %s",GetName());
      return 1;
   }
}

//______________________________________________________________________________
TFile* TBranch::GetFile(Int_t mode)
{
   // Return pointer to the file where branch buffers reside, returns 0
   // in case branch buffers reside in the same file as tree header.
   // If mode is 1 the branch buffer file is recreated.

   if (fDirectory) return fDirectory->GetFile();

   // check if a file with this name is in the list of Root files
   TFile *file = 0;
   {
      R__LOCKGUARD2(gROOTMutex);
      file = (TFile*)gROOT->GetListOfFiles()->FindObject(fFileName.Data());
      if (file) {
         fDirectory = file;
         return file;
      }
   }

   if (fFileName.Length() == 0) return 0;

   TString bFileName( GetRealFileName() );

   // Open file (new file if mode = 1)
   {
      TDirectory::TContext ctxt(0);
      if (mode) file = TFile::Open(bFileName, "recreate");
      else      file = TFile::Open(bFileName);
   }
   if (!file) return 0;
   if (file->IsZombie()) {delete file; return 0;}
   fDirectory = (TDirectory*)file;
   return file;
}

//______________________________________________________________________________
TBasket* TBranch::GetFreshBasket()
{
   // Return a fresh basket by either resusing an existing basket that needs
   // to be drop (according to TTree::MemoryFull) or create a new one.

   TBasket *basket = 0;  
   if (GetTree()->MemoryFull(0)) {
      if (fNBaskets==1) {
         // Steal the existing basket
         Int_t oldindex = fBaskets.GetLast();
         basket = (TBasket*)fBaskets.UncheckedAt(oldindex);
         if (!basket) {
            fBaskets.SetLast(-2); // For recalculation of Last.
            oldindex = fBaskets.GetLast();
            basket = (TBasket*)fBaskets.UncheckedAt(oldindex);
         }
         if (basket && fBasketBytes[oldindex]!=0) {
            if (basket == fCurrentBasket) {
               fCurrentBasket    = 0;
               fFirstBasketEntry = -1;
               fNextBasketEntry  = -1;
            }            
            fBaskets.AddAt(0,oldindex);
            fBaskets.SetLast(-1);
            fNBaskets = 0;
         } else {
            basket = fTree->CreateBasket(this);
         }            
      } else if (fNBaskets == 0) {
         // There is nothing to drop!
         basket = fTree->CreateBasket(this);
      } else {
         // Memory is full and there is more than one basket,
         // Let DropBaskets do it job.
         DropBaskets();
         basket = fTree->CreateBasket(this);
      }
   } else {
      basket = fTree->CreateBasket(this);
   }   
   return basket;
}

//______________________________________________________________________________
TLeaf* TBranch::GetLeaf(const char* name) const
{
   //           Return pointer to the 1st Leaf named name in thisBranch

   Int_t i;
   for (i=0;i<fNleaves;i++) {
      TLeaf *leaf = (TLeaf*)fLeaves.UncheckedAt(i);
      if (!strcmp(leaf->GetName(),name)) return leaf;
   }
   return 0;
}

//______________________________________________________________________________
TString TBranch::GetRealFileName() const
{
   if (fFileName.Length()==0) {
      return fFileName;
   }
   TString bFileName = fFileName;

   // check if branch file name is absolute or a URL (e.g. /castor/...,
   // root://host/..., rfio:/path/...)
   char *bname = gSystem->ExpandPathName(fFileName.Data());
   if (!gSystem->IsAbsoluteFileName(bname) && !strstr(bname, ":/") && fTree && fTree->GetCurrentFile()) {

      // if not, get filename where tree header is stored
      const char *tfn = fTree->GetCurrentFile()->GetName();

      // If it is an archive file we need a special treatment
      TUrl arc(tfn);
      if (strlen(arc.GetAnchor()) > 0) {
         arc.SetAnchor(gSystem->BaseName(fFileName));
         bFileName = arc.GetUrl();
      } else {
         // if this is an absolute path or a URL then prepend this path
         // to the branch file name
         char *tname = gSystem->ExpandPathName(tfn);
         if (gSystem->IsAbsoluteFileName(tname) || strstr(tname, ":/")) {
            bFileName = gSystem->DirName(tname);
            bFileName += "/";
            bFileName += fFileName;
         }
         delete [] tname;
      }
   }
   delete [] bname;

   return bFileName;
}

//______________________________________________________________________________
Int_t TBranch::GetRow(Int_t)
{
   // Return all elements of one row unpacked in internal array fValues
   // [Actually just returns 1 (?)]

   return 1;
}

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

   // Regular TBranch and TBrancObject can not be in makeClass mode

   return kFALSE;
}

//______________________________________________________________________________
TBranch* TBranch::GetMother() const
{
   // Get our top-level parent branch in the tree.

   if (fMother) return fMother;

   const TObjArray* array = fTree->GetListOfBranches();
   Int_t n = array->GetEntriesFast();
   for (Int_t i = 0; i < n; ++i) {
      TBranch* branch = (TBranch*) array->UncheckedAt(i);
      TBranch* parent = branch->GetSubBranch(this);
      if (parent) {
         const_cast<TBranch*>(this)->fMother = branch; // We can not yet use the 'mutable' keyword
         return branch;
      }
   }
   return 0;
}

//______________________________________________________________________________
TBranch* TBranch::GetSubBranch(const TBranch* child) const
{
   // Find the parent branch of child.
   // Return 0 if child is not in this branch hierarchy.

   // Handle error condition, if the parameter is us, we cannot find the parent.
   if (this == child) {
      // Note: We cast away any const-ness of "this".
      return (TBranch*) this;
   }

   if (child->fParent) {
      return child->fParent;
   }

   Int_t len = fBranches.GetEntriesFast();
   for (Int_t i = 0; i < len; ++i) {
      TBranch* branch = (TBranch*) fBranches.UncheckedAt(i);
      if (!branch) {
         continue;
      }
      if (branch == child) {
         // We are the direct parent of child.
         const_cast<TBranch*>(child)->fParent = (TBranch*)this; // We can not yet use the 'mutable' keyword
         // Note: We cast away any const-ness of "this".
         const_cast<TBranch*>(child)->fParent = (TBranch*)this; // We can not yet use the 'mutable' keyword
         return (TBranch*) this;
      }
      // FIXME: This is a tail-recursion!
      TBranch* parent = branch->GetSubBranch(child);
      if (parent) {
         return parent;
      }
   }
   // We failed to find the parent.
   return 0;
}

//______________________________________________________________________________
Long64_t TBranch::GetTotalSize(Option_t * /*option*/) const
{
   // Return total number of bytes in the branch (including current buffer)

   TObjArray &baskets( const_cast<TObjArray&>(fBaskets) );
   TBasket *writebasket = 0;
   if (fNBaskets == 1) {
      writebasket = (TBasket*)fBaskets.UncheckedAt(fWriteBasket);
      if (writebasket && writebasket->GetNevBuf()==0) {
         baskets[fWriteBasket] = 0;
      } else {
         writebasket = 0;
      }
   }
   TBufferFile b(TBuffer::kWrite,10000);
   TBranch::Class()->WriteBuffer(b,(TBranch*)this);
   if (writebasket) {
      baskets[fWriteBasket] = writebasket;         
   }
   Long64_t totbytes = 0;
   if (fZipBytes > 0) totbytes = fTotBytes;
   return totbytes + b.Length();
}

//______________________________________________________________________________
Long64_t TBranch::GetTotBytes(Option_t *option) const
{
   // Return total number of bytes in the branch (excluding current buffer)
   // if option ="*" includes all sub-branches of this branch too

   Long64_t totbytes = fTotBytes;
   if (!option) return totbytes;
   if (option[0] != '*') return totbytes;
   //scan sub-branches
   Int_t len = fBranches.GetEntriesFast();
   for (Int_t i = 0; i < len; ++i) {
      TBranch* branch = (TBranch*) fBranches.UncheckedAt(i);
      if (branch) totbytes += branch->GetTotBytes();
   }
   return totbytes;
}

//______________________________________________________________________________
Long64_t TBranch::GetZipBytes(Option_t *option) const
{
   // Return total number of zip bytes in the branch
   // if option ="*" includes all sub-branches of this branch too

   Long64_t zipbytes = fZipBytes;
   if (!option) return zipbytes;
   if (option[0] != '*') return zipbytes;
   //scan sub-branches
   Int_t len = fBranches.GetEntriesFast();
   for (Int_t i = 0; i < len; ++i) {
      TBranch* branch = (TBranch*) fBranches.UncheckedAt(i);
      if (branch) zipbytes += branch->GetZipBytes();
   }
   return zipbytes;
}

//______________________________________________________________________________
Bool_t TBranch::IsAutoDelete() const
{
   // Return kTRUE if an existing object in a TBranchObject must be deleted.
   return TestBit(kAutoDelete);
}

//______________________________________________________________________________
Bool_t TBranch::IsFolder() const
{
   // Return kTRUE if more than one leaf or browsables, kFALSE otherwise.
   if (fNleaves > 1) {
      return kTRUE;
   }
   TList* browsables = const_cast<TBranch*>(this)->GetBrowsables();
   return browsables && browsables->GetSize();
}

//______________________________________________________________________________
void TBranch::KeepCircular(Long64_t maxEntries)
{
   // keep a maximum of fMaxEntries in memory

   Int_t dentries = (Int_t) (fEntries - maxEntries);
   TBasket* basket = (TBasket*) fBaskets.UncheckedAt(0);
   if (basket) basket->MoveEntries(dentries);
   fEntries = maxEntries;
   fEntryNumber = maxEntries;
   //loop on sub branches
   Int_t nb = fBranches.GetEntriesFast();
   for (Int_t i = 0; i < nb; ++i)  {
      TBranch* branch = (TBranch*) fBranches.UncheckedAt(i);
      branch->KeepCircular(maxEntries);
   }
}

//______________________________________________________________________________
Int_t TBranch::LoadBaskets()
{
   //  Baskets associated to this branch are forced to be in memory.
   //  You can call TTree::SetMaxVirtualSize(maxmemory) to instruct
   //  the system that the total size of the imported baskets does not
   //  exceed maxmemory bytes.
   //  The function returns the number of baskets that have been put in memory.
   //  This method may be called to force all baskets of one or more branches
   //  in memory when random access to entries in this branch is required.
   //  See also TTree::LoadBaskets to load all baskets of all branches in memory.

   Int_t nimported = 0;
   Int_t nbaskets = fWriteBasket;
   TFile *file = GetFile(0);
   if (!file) return 0;
   TBasket *basket;
   for (Int_t i=0;i<nbaskets;i++) {
      basket = (TBasket*)fBaskets.UncheckedAt(i);
      if (basket) continue;
      basket = GetFreshBasket();
      if (fBasketBytes[i] == 0) {
         fBasketBytes[i] = basket->ReadBasketBytes(fBasketSeek[i],file);
      }
      Int_t badread = basket->ReadBasketBuffers(fBasketSeek[i],fBasketBytes[i],file);
      if (badread) {
         Error("Loadbaskets","Error while reading basket buffer %d of branch %s",i,GetName());
         return -1;
      }
      ++fNBaskets;
      fBaskets.AddAt(basket,i);
      nimported++;
   }
   return nimported;
}

//______________________________________________________________________________
void TBranch::Print(Option_t*) const
{
   // Print TBranch parameters

   const int kLINEND = 77;
   Float_t cx = 1;

   TString titleContent(GetTitle());
   if ( titleContent == GetName() ) {
      titleContent.Clear();
   }

   if (fLeaves.GetEntries() == 1) {
      if (titleContent.Length()>=2 && titleContent[titleContent.Length()-2]=='/' && isalpha(titleContent[titleContent.Length()-1])) {
         // The type is already encoded.  Nothing to do.
      } else {
         TLeaf *leaf = (TLeaf*)fLeaves.UncheckedAt(0);
         if (titleContent.Length()) {
            titleContent.Prepend(" ");
         }
         // titleContent.Append("type: ");
         titleContent.Prepend(leaf->GetTypeName());
      }
   }
   Int_t titleLength = titleContent.Length();

   Int_t aLength = titleLength + strlen(GetName());
   aLength += (aLength / 54 + 1) * 80 + 100;
   if (aLength < 200) aLength = 200;
   char *bline = new char[aLength];

   Long64_t totBytes = GetTotalSize();
   if (fZipBytes) cx = (fTotBytes+0.00001)/fZipBytes;
   if (titleLength) snprintf(bline,aLength,"*Br%5d :%-9s : %-54s *",fgCount,GetName(),titleContent.Data());
   else             snprintf(bline,aLength,"*Br%5d :%-9s : %-54s *",fgCount,GetName()," ");
   if (strlen(bline) > UInt_t(kLINEND)) {
      char *tmp = new char[strlen(bline)+1];
      if (titleLength) strlcpy(tmp, titleContent.Data(),strlen(bline)+1);
      snprintf(bline,aLength,"*Br%5d :%-9s : ",fgCount,GetName());
      int pos = strlen (bline);
      int npos = pos;
      int beg=0, end;
      while (beg < titleLength) {
         for (end=beg+1; end < titleLength-1; end ++)
            if (tmp[end] == ':')  break;
         if (npos + end-beg+1 >= 78) {
            while (npos < kLINEND) {
               bline[pos ++] = ' ';
               npos ++;
            }
            bline[pos ++] = '*';
            bline[pos ++] = '\n';
            bline[pos ++] = '*';
            npos = 1;
            for (; npos < 12; npos ++)
               bline[pos ++] = ' ';
            bline[pos-2] = '|';
         }
         for (int n = beg; n <= end; n ++)
            bline[pos+n-beg] = tmp[n];
         pos += end-beg+1;
         npos += end-beg+1;
         beg = end+1;
      }
      while (npos < kLINEND) {
         bline[pos ++] = ' ';
         npos ++;
      }
      bline[pos ++] = '*';
      bline[pos] = '\0';
      delete[] tmp;
   }
   Printf("%s", bline);
   if (fTotBytes > 2000000000) {
      Printf("*Entries :%lld : Total  Size=%11lld bytes  File Size  = %lld *",fEntries,totBytes,fZipBytes);
   } else {
      if (fZipBytes > 0) {
         Printf("*Entries :%9lld : Total  Size=%11lld bytes  File Size  = %10lld *",fEntries,totBytes,fZipBytes);
      } else {
         if (fWriteBasket > 0) {
            Printf("*Entries :%9lld : Total  Size=%11lld bytes  All baskets in memory   *",fEntries,totBytes);
         } else {
            Printf("*Entries :%9lld : Total  Size=%11lld bytes  One basket in memory    *",fEntries,totBytes);
         }
      }
   }
   Printf("*Baskets :%9d : Basket Size=%11d bytes  Compression= %6.2f     *",fWriteBasket,fBasketSize,cx);
   Printf("*............................................................................*");
   delete [] bline;
   fgCount++;
}

//______________________________________________________________________________
void TBranch::ReadBasket(TBuffer&)
{
   // Loop on all leaves of this branch to read Basket buffer.

   //   fLeaves->ReadBasket(basket);
}

//______________________________________________________________________________
void TBranch::ReadLeavesImpl(TBuffer& b)
{
   // Loop on all leaves of this branch to read Basket buffer.

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

//______________________________________________________________________________
void TBranch::ReadLeaves0Impl(TBuffer&)
{
   // Read zero leaves without the overhead of a loop.

}

//______________________________________________________________________________
void TBranch::ReadLeaves1Impl(TBuffer& b)
{
   // Read one leaf without the overhead of a loop.

   ((TLeaf*) fLeaves.UncheckedAt(0))->ReadBasket(b);
}

//______________________________________________________________________________
void TBranch::ReadLeaves2Impl(TBuffer& b)
{
   // Read two leaves without the overhead of a loop.

   ((TLeaf*) fLeaves.UncheckedAt(0))->ReadBasket(b);
   ((TLeaf*) fLeaves.UncheckedAt(1))->ReadBasket(b);
}

//______________________________________________________________________________
void TBranch::FillLeavesImpl(TBuffer& b)
{
   // Loop on all leaves of this branch to fill Basket buffer.

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

//______________________________________________________________________________
void TBranch::Refresh(TBranch* b)
{
   //  refresh this branch using new information in b
   //  This function is called by TTree::Refresh

   if (b==0) return;

   fEntryOffsetLen = b->fEntryOffsetLen;
   fWriteBasket    = b->fWriteBasket;
   fEntryNumber    = b->fEntryNumber;
   fMaxBaskets     = b->fMaxBaskets;
   fEntries        = b->fEntries;
   fTotBytes       = b->fTotBytes;
   fZipBytes       = b->fZipBytes;
   fReadBasket     = 0;
   fReadEntry      = -1;
   fFirstBasketEntry = -1;
   fNextBasketEntry  = -1;
   fCurrentBasket    =  0;
   delete [] fBasketBytes;
   delete [] fBasketEntry;
   delete [] fBasketSeek;
   fBasketBytes = new Int_t[fMaxBaskets];
   fBasketEntry = new Long64_t[fMaxBaskets];
   fBasketSeek  = new Long64_t[fMaxBaskets];
   Int_t i;
   for (i=0;i<fMaxBaskets;i++) {
      fBasketBytes[i] = b->fBasketBytes[i];
      fBasketEntry[i] = b->fBasketEntry[i];
      fBasketSeek[i]  = b->fBasketSeek[i];
   }
   fBaskets.Delete();
   Int_t nbaskets = b->fBaskets.GetSize();
   fBaskets.Expand(nbaskets);
   // If the current fWritebasket is in memory, take it (just swap)
   // from the Tree being read
   TBasket *basket = (TBasket*)b->fBaskets.UncheckedAt(fWriteBasket);
   fBaskets.AddAt(basket,fWriteBasket);
   if (basket) {
      fNBaskets = 1;
      --(b->fNBaskets);
      b->fBaskets.RemoveAt(fWriteBasket);
      basket->SetBranch(this);
   }
}

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

   fReadBasket = 0;
   fReadEntry = -1;
   fFirstBasketEntry = -1;
   fNextBasketEntry = -1;
   fCurrentBasket   = 0;
   fWriteBasket = 0;
   fEntries = 0;
   fTotBytes = 0;
   fZipBytes = 0;
   fEntryNumber = 0;

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

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

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

   fBaskets.Delete();
   fNBaskets = 0;
}


//______________________________________________________________________________
void TBranch::ResetAfterMerge(TFileMergeInfo *)
{
   // Reset a Branch.
   //
   // Existing buffers are deleted.
   // Entries, max and min are reset.
   //

   fReadBasket       = 0;
   fReadEntry        = -1;
   fFirstBasketEntry = -1;
   fNextBasketEntry  = -1;
   fCurrentBasket    = 0;
   fWriteBasket      = 0;
   fEntries          = 0;
   fTotBytes         = 0;
   fZipBytes         = 0;
   fEntryNumber      = 0;

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

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

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

   TBasket *reusebasket = (TBasket*)fBaskets[fWriteBasket];
   if (reusebasket) {
      fBaskets[fWriteBasket] = 0;
   } else {
      reusebasket = (TBasket*)fBaskets[fReadBasket];
      if (reusebasket) {
         fBaskets[fReadBasket] = 0;
      }
   }
   fBaskets.Delete();
   if (reusebasket) {
      fNBaskets = 1;
      reusebasket->Reset();
      fBaskets[0] = reusebasket;
   } else {
      fNBaskets = 0;
   }
}

//______________________________________________________________________________
void TBranch::ResetAddress()
{
   // Reset the address of the branch.

   fAddress = 0;

   //  Reset last read entry number, we have will had new user object now.
   fReadEntry = -1;
   fFirstBasketEntry = -1;
   fNextBasketEntry  = -1;

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

   Int_t nbranches = fBranches.GetEntriesFast();
   for (Int_t i = 0; i < nbranches; ++i)  {
      TBranch* abranch = (TBranch*) fBranches[i];
      // FIXME: This is a tail recursion.
      abranch->ResetAddress();
   }
}

//______________________________________________________________________________
void TBranch::ResetCount()
{
   // Static function resetting fgCount
   fgCount = 0;
}

//______________________________________________________________________________
void TBranch::SetAddress(void* addr)
{
   // Set address of this branch.
   if (TestBit(kDoNotProcess)) {
      return;
   }
   fReadEntry = -1;
   fFirstBasketEntry = -1;
   fNextBasketEntry  = -1;
   fAddress = (char*) addr;
   for (Int_t i = 0; i < fNleaves; ++i) {
      TLeaf* leaf = (TLeaf*) fLeaves.UncheckedAt(i);
      Int_t offset = leaf->GetOffset();
      if (TestBit(kIsClone)) {
         offset = 0;
      }
      if (fAddress) leaf->SetAddress(fAddress + offset);
      else leaf->SetAddress(0);
   }
}

//______________________________________________________________________________
void TBranch::SetAutoDelete(Bool_t autodel)
{
   // Set the automatic delete bit.
   //
   // This bit is used by TBranchObject::ReadBasket to decide if an object
   // referenced by a TBranchObject must be deleted or not before reading
   // a new entry.
   //
   // If autodel is kTRUE, this existing object will be deleted, a new object
   // created by the default constructor, then read from disk by the streamer.
   //
   // If autodel is kFALSE, the existing object is not deleted.  Root assumes
   // that the user is taking care of deleting any internal object or array
   // (this can be done in the streamer).

   if (autodel) {
      SetBit(kAutoDelete, 1);
   } else {
      SetBit(kAutoDelete, 0);
   }
}

//______________________________________________________________________________
void TBranch::SetBasketSize(Int_t buffsize)
{
   // Set the basket size
   // The function makes sure that the basket size is greater than fEntryOffsetlen

   Int_t minsize = 100 + fName.Length();
   if (buffsize < minsize+fEntryOffsetLen) buffsize = minsize+fEntryOffsetLen;
   fBasketSize = buffsize;
   TBasket *basket = (TBasket*)fBaskets[fWriteBasket];
   if (basket) {
      basket->AdjustSize(fBasketSize);
   }
}

//______________________________________________________________________________
void TBranch::SetBufferAddress(TBuffer* buf)
{
   // -- Set address of this branch directly from a TBuffer to avoid streaming.
   //
   // Note: We do not take ownership of the buffer.
   //

   // Check this is possible
   if ( (fNleaves != 1)
       || (strcmp("TLeafObject",fLeaves.UncheckedAt(0)->ClassName())!=0) ) {
      Error("TBranch::SetAddress","Filling from a TBuffer can only be done with a not split object branch.  Request ignored.");
   } else {
      fReadEntry = -1;
      fNextBasketEntry  = -1;
      fFirstBasketEntry = -1;
      // Note: We do not take ownership of the buffer.
      fEntryBuffer = buf;
   }
}

//______________________________________________________________________________
void TBranch::SetCompressionAlgorithm(Int_t algorithm)
{
   if (algorithm < 0 || algorithm >= ROOT::kUndefinedCompressionAlgorithm) algorithm = 0;
   if (fCompress < 0) {
      fCompress = 100 * algorithm + 1;
   } else {
      int level = fCompress % 100;
      fCompress = 100 * algorithm + level;
   }

   Int_t nb = fBranches.GetEntriesFast();
   for (Int_t i=0;i<nb;i++) {
      TBranch *branch = (TBranch*)fBranches.UncheckedAt(i);
      branch->SetCompressionAlgorithm(algorithm);
   }
}

//______________________________________________________________________________
void TBranch::SetCompressionLevel(Int_t level)
{
   if (level < 0) level = 0;
   if (level > 99) level = 99;
   if (fCompress < 0) {
      fCompress = level;
   } else {
      int algorithm = fCompress / 100;
      if (algorithm >= ROOT::kUndefinedCompressionAlgorithm) algorithm = 0;
      fCompress = 100 * algorithm + level;
   }

   Int_t nb = fBranches.GetEntriesFast();
   for (Int_t i=0;i<nb;i++) {
      TBranch *branch = (TBranch*)fBranches.UncheckedAt(i);
      branch->SetCompressionLevel(level);
   }
}

//______________________________________________________________________________
void TBranch::SetCompressionSettings(Int_t settings)
{
   fCompress = settings;

   Int_t nb = fBranches.GetEntriesFast();
   for (Int_t i=0;i<nb;i++) {
      TBranch *branch = (TBranch*)fBranches.UncheckedAt(i);
      branch->SetCompressionSettings(settings);
   }
}

//______________________________________________________________________________
void TBranch::SetEntryOffsetLen(Int_t newdefault, Bool_t updateExisting)
{
   // Update the default value for the branch's fEntryOffsetLen if and only if
   // it was already non zero (and the new value is not zero)
   // If updateExisting is true, also update all the existing branches.

   if (fEntryOffsetLen && newdefault) {
      fEntryOffsetLen = newdefault;
   }
   if (updateExisting) {
      TIter next( GetListOfBranches() );
      TBranch *b;
      while ( ( b = (TBranch*)next() ) ) {
         b->SetEntryOffsetLen( newdefault, kTRUE );
      }
   }
}

//______________________________________________________________________________
void TBranch::SetEntries(Long64_t entries)
{
   // Set the number of entries in this branch.

   fEntries = entries;
   fEntryNumber = entries;
}

//______________________________________________________________________________
void TBranch::SetFile(TFile* file)
{
   // Set file where this branch writes/reads its buffers.
   // By default the branch buffers reside in the file where the
   // Tree was created.
   // If the file name where the tree was created is an absolute
   // path name or an URL (e.g. /castor/... or root://host/...)
   // and if the fname is not an absolute path name or an URL then
   // the path of the tree file is prepended to fname to make the
   // branch file relative to the tree file. In this case one can
   // move the tree + all branch files to a different location in
   // the file system and still access the branch files.
   // The ROOT file will be connected only when necessary.
   // If called by TBranch::Fill (via TBasket::WriteFile), the file
   // will be created with the option "recreate".
   // If called by TBranch::GetEntry (via TBranch::GetBasket), the file
   // will be opened in read mode.
   // To open a file in "update" mode or with a certain compression
   // level, use TBranch::SetFile(TFile *file).

   if (file == 0) file = fTree->GetCurrentFile();
   fDirectory = (TDirectory*)file;
   if (file == fTree->GetCurrentFile()) fFileName = "";
   else                                 fFileName = file->GetName();

   if (file && fCompress == -1) {
      fCompress = file->GetCompressionLevel();      
   }

   // Apply to all existing baskets.
   TIter nextb(GetListOfBaskets());
   TBasket *basket;
   while ((basket = (TBasket*)nextb())) {
      basket->SetParent(file);
   }

   // Apply to sub-branches as well.
   TIter next(GetListOfBranches());
   TBranch *branch;
   while ((branch = (TBranch*)next())) {
      branch->SetFile(file);
   }
}

//______________________________________________________________________________
void TBranch::SetFile(const char* fname)
{
   // Set file where this branch writes/reads its buffers.
   // By default the branch buffers reside in the file where the
   // Tree was created.
   // If the file name where the tree was created is an absolute
   // path name or an URL (e.g. /castor/... or root://host/...)
   // and if the fname is not an absolute path name or an URL then
   // the path of the tree file is prepended to fname to make the
   // branch file relative to the tree file. In this case one can
   // move the tree + all branch files to a different location in
   // the file system and still access the branch files.
   // The ROOT file will be connected only when necessary.
   // If called by TBranch::Fill (via TBasket::WriteFile), the file
   // will be created with the option "recreate".
   // If called by TBranch::GetEntry (via TBranch::GetBasket), the file
   // will be opened in read mode.
   // To open a file in "update" mode or with a certain compression
   // level, use TBranch::SetFile(TFile *file).

   fFileName  = fname;
   fDirectory = 0;

   //apply to sub-branches as well
   TIter next(GetListOfBranches());
   TBranch *branch;
   while ((branch = (TBranch*)next())) {
      branch->SetFile(fname);
   }
}

//______________________________________________________________________________
Bool_t TBranch::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).

   // Regular TBranch and TBrancObject can not be in makeClass mode
   return kFALSE;
}

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

   if (TestBit(kDoNotProcess)) {
      return;
   }
   Warning("SetObject","is not supported in TBranch objects");
}

//______________________________________________________________________________
void TBranch::SetStatus(Bool_t status)
{
   // Set branch status to Process or DoNotProcess.

   if (status) ResetBit(kDoNotProcess);
   else        SetBit(kDoNotProcess);
}

//_______________________________________________________________________
void TBranch::Streamer(TBuffer& b)
{
   // Stream a class object

   if (b.IsReading()) {
      UInt_t R__s, R__c;
      fTree = 0; // Will be set by TTree::Streamer
      fAddress = 0;
      gROOT->SetReadingObject(kTRUE);

      // Reset transients.
      SetBit(TBranch::kDoNotUseBufferMap);
      fCurrentBasket    = 0;
      fFirstBasketEntry = -1;
      fNextBasketEntry  = -1;

      Version_t v = b.ReadVersion(&R__s, &R__c);
      if (v > 9) {
         b.ReadClassBuffer(TBranch::Class(), this, v, R__s, R__c);

         if (fWriteBasket>=fBaskets.GetSize()) {
            fBaskets.Expand(fWriteBasket+1);
         }
         fDirectory = 0;
         fNleaves = fLeaves.GetEntriesFast();
         for (Int_t i=0;i<fNleaves;i++) {
            TLeaf *leaf = (TLeaf*)fLeaves.UncheckedAt(i);
            leaf->SetBranch(this);
         }

         fNBaskets = fBaskets.GetEntries();
         for (Int_t j=fWriteBasket,n=0;j>=0 && n<fNBaskets;--j) {
            TBasket *bk = (TBasket*)fBaskets.UncheckedAt(j);
            if (bk) {
               bk->SetBranch(this);
               // GetTree()->IncrementTotalBuffers(bk->GetBufferSize());
               ++n;
            }
         }
         if (fWriteBasket >= fMaxBaskets) {
            //old versions may need this fix
            ExpandBasketArrays();
            fBasketBytes[fWriteBasket] = fBasketBytes[fWriteBasket-1];
            fBasketEntry[fWriteBasket] = fEntries;
            fBasketSeek [fWriteBasket] = fBasketSeek [fWriteBasket-1];

         }
         if (!fSplitLevel && fBranches.GetEntriesFast()) fSplitLevel = 1;
         gROOT->SetReadingObject(kFALSE);
         if (IsA() == TBranch::Class()) {
            if (fNleaves == 0) {
               fReadLeaves = &TBranch::ReadLeaves0Impl;
            } else if (fNleaves == 1) {
               fReadLeaves = &TBranch::ReadLeaves1Impl;
            } else if (fNleaves == 2) {
               fReadLeaves = &TBranch::ReadLeaves2Impl;
            } else {
               fReadLeaves = &TBranch::ReadLeavesImpl;
            }
         }
         return;
      }
      //====process old versions before automatic schema evolution
      Int_t n,i,j,ijunk;
      if (v > 5) {
         Stat_t djunk;
         TNamed::Streamer(b);
         if (v > 7) TAttFill::Streamer(b);
         b >> fCompress;
         b >> fBasketSize;
         b >> fEntryOffsetLen;
         b >> fWriteBasket;
         b >> ijunk; fEntryNumber = (Long64_t)ijunk;
         b >> fOffset;
         b >> fMaxBaskets;
         if (v > 6) b >> fSplitLevel;
         b >> djunk; fEntries  = (Long64_t)djunk;
         b >> djunk; fTotBytes = (Long64_t)djunk;
         b >> djunk; fZipBytes = (Long64_t)djunk;

         fBranches.Streamer(b);
         fLeaves.Streamer(b);
         fBaskets.Streamer(b);
         fBasketBytes = new Int_t[fMaxBaskets];
         fBasketEntry = new Long64_t[fMaxBaskets];
         fBasketSeek  = new Long64_t[fMaxBaskets];
         Char_t isArray;
         b >> isArray;
         b.ReadFastArray(fBasketBytes,fMaxBaskets);
         b >> isArray;
         for (i=0;i<fMaxBaskets;i++) {b >> ijunk; fBasketEntry[i] = ijunk;}
         b >> isArray;
         for (i=0;i<fMaxBaskets;i++) {
            if (isArray == 2) b >> fBasketSeek[i];
            else              {Int_t bsize; b >> bsize; fBasketSeek[i] = (Long64_t)bsize;};
         }
         fFileName.Streamer(b);
         b.CheckByteCount(R__s, R__c, TBranch::IsA());
         fDirectory = 0;
         fNleaves = fLeaves.GetEntriesFast();
         for (i=0;i<fNleaves;i++) {
            TLeaf *leaf = (TLeaf*)fLeaves.UncheckedAt(i);
            leaf->SetBranch(this);
         }
         fNBaskets = fBaskets.GetEntries();
         for (j=fWriteBasket,n=0;j>=0 && n<fNBaskets;--j) {
            TBasket *bk = (TBasket*)fBaskets.UncheckedAt(j);
            if (bk) {
               bk->SetBranch(this);
               //GetTree()->IncrementTotalBuffers(bk->GetBufferSize());
               ++n;
            }
         }
         if (fWriteBasket >= fMaxBaskets) {
            //old versions may need this fix
            ExpandBasketArrays();
            fBasketBytes[fWriteBasket] = fBasketBytes[fWriteBasket-1];
            fBasketEntry[fWriteBasket] = fEntries;
            fBasketSeek [fWriteBasket] = fBasketSeek [fWriteBasket-1];

         }
         // Check Byte Count is not needed since it was done in ReadBuffer
         if (!fSplitLevel && fBranches.GetEntriesFast()) fSplitLevel = 1;
         gROOT->SetReadingObject(kFALSE);
         b.CheckByteCount(R__s, R__c, TBranch::IsA());
         if (IsA() == TBranch::Class()) {
            if (fNleaves == 0) {
               fReadLeaves = &TBranch::ReadLeaves0Impl;
            } else if (fNleaves == 1) {
               fReadLeaves = &TBranch::ReadLeaves1Impl;
            } else if (fNleaves == 2) {
               fReadLeaves = &TBranch::ReadLeaves2Impl;
            } else {
               fReadLeaves = &TBranch::ReadLeavesImpl;
            }
         }
         return;
      }
      //====process very old versions
      Stat_t djunk;
      TNamed::Streamer(b);
      b >> fCompress;
      b >> fBasketSize;
      b >> fEntryOffsetLen;
      b >> fMaxBaskets;
      b >> fWriteBasket;
      b >> ijunk; fEntryNumber = (Long64_t)ijunk;
      b >> djunk; fEntries  = (Long64_t)djunk;
      b >> djunk; fTotBytes = (Long64_t)djunk;
      b >> djunk; fZipBytes = (Long64_t)djunk;
      b >> fOffset;
      fBranches.Streamer(b);
      fLeaves.Streamer(b);
      fNleaves = fLeaves.GetEntriesFast();
      for (i=0;i<fNleaves;i++) {
         TLeaf *leaf = (TLeaf*)fLeaves.UncheckedAt(i);
         leaf->SetBranch(this);
      }
      fBaskets.Streamer(b);
      Int_t nbaskets = fBaskets.GetEntries();
      for (j=fWriteBasket,n=0;j>0 && n<nbaskets;--j) {
         TBasket *bk = (TBasket*)fBaskets.UncheckedAt(j);
         if (bk) {
            bk->SetBranch(this);
            //GetTree()->IncrementTotalBuffers(bk->GetBufferSize());
            ++n;
         }
      }
      fBasketEntry = new Long64_t[fMaxBaskets];
      b >> n;
      for (i=0;i<n;i++) {b >> ijunk; fBasketEntry[i] = ijunk;}
      fBasketBytes = new Int_t[fMaxBaskets];
      if (v > 4) {
         n  = b.ReadArray(fBasketBytes);
      } else {
         for (n=0;n<fMaxBaskets;n++) fBasketBytes[n] = 0;
      }
      if (v < 2) {
         fBasketSeek = new Long64_t[fMaxBaskets];
         for (n=0;n<fWriteBasket;n++) {
            TBasket *basket = GetBasket(n);
            fBasketSeek[n] = basket ? basket->GetSeekKey() : 0;
         }
      } else {
         fBasketSeek = new Long64_t[fMaxBaskets];
         b >> n;
         for (n=0;n<fMaxBaskets;n++) {
            Int_t aseek;
            b >> aseek;
            fBasketSeek[n] = Long64_t(aseek);
         }
      }
      if (v > 2) {
         fFileName.Streamer(b);
      }
      fDirectory = 0;
      if (v < 4) SetAutoDelete(kTRUE);
      if (!fSplitLevel && fBranches.GetEntriesFast()) fSplitLevel = 1;
      gROOT->SetReadingObject(kFALSE);
      b.CheckByteCount(R__s, R__c, TBranch::IsA());
      //====end of old versions
      if (IsA() == TBranch::Class()) {
         if (fNleaves == 0) {
            fReadLeaves = &TBranch::ReadLeaves0Impl;
         } else if (fNleaves == 1) {
            fReadLeaves = &TBranch::ReadLeaves1Impl;
         } else if (fNleaves == 2) {
            fReadLeaves = &TBranch::ReadLeaves2Impl;
         } else {
            fReadLeaves = &TBranch::ReadLeavesImpl;
         }
      }
   } else {
      Int_t maxBaskets = fMaxBaskets;
      fMaxBaskets = fWriteBasket+1;
      if (fMaxBaskets < 10) fMaxBaskets=10;
      TBasket *writebasket = 0;
      if (fNBaskets == 1) {
         writebasket = (TBasket*)fBaskets.UncheckedAt(fWriteBasket);
         if (writebasket && writebasket->GetNevBuf()==0) {
            fBaskets[fWriteBasket] = 0;
         } else {
            writebasket = 0;
         }
      }
      b.WriteClassBuffer(TBranch::Class(),this);
      if (writebasket) {
         fBaskets[fWriteBasket] = writebasket;         
      }
      fMaxBaskets = maxBaskets;
   }
}

//_______________________________________________________________________
Int_t TBranch::WriteBasket(TBasket* basket, Int_t where)
{
   // Write the current basket to disk and return the number of bytes
   // written to the file.

   Int_t nevbuf = basket->GetNevBuf();
   if (fEntryOffsetLen > 10 &&  (4*nevbuf) < fEntryOffsetLen ) {
      // Make sure that the fEntryOffset array does not stay large unnecessarily.
      fEntryOffsetLen = nevbuf < 3 ? 10 : 4*nevbuf; // assume some fluctuations.
   } else if (fEntryOffsetLen && nevbuf > fEntryOffsetLen) {
      // Increase the array ... 
      fEntryOffsetLen = 2*nevbuf; // assume some fluctuations.
   }

   Int_t nout  = basket->WriteBuffer();    //  Write buffer
   fBasketBytes[where]  = basket->GetNbytes();
   fBasketSeek[where]   = basket->GetSeekKey();
   Int_t addbytes = basket->GetObjlen() + basket->GetKeylen();
   TBasket *reusebasket = 0;
   if (nout>0) {
      // The Basket was written so we can now safely reuse it.
      fBaskets[where] = 0;

      reusebasket = basket;
      reusebasket->Reset();

      fZipBytes += nout;
      fTotBytes += addbytes;
      fTree->AddTotBytes(addbytes);
      fTree->AddZipBytes(nout);
   }

   if (where==fWriteBasket) {
      ++fWriteBasket;
      if (fWriteBasket >= fMaxBaskets) {
         ExpandBasketArrays();
      }
      fBaskets.AddAtAndExpand(reusebasket,fWriteBasket);
      fBasketEntry[fWriteBasket] = fEntryNumber;
   } else {
      --fNBaskets;
      fBaskets[where] = 0;
      basket->DropBuffers();
      if (basket == fCurrentBasket) {
         fCurrentBasket    = 0;
         fFirstBasketEntry = -1;
         fNextBasketEntry  = -1;
      }      
      delete basket;
   }

   return nout;
}

//------------------------------------------------------------------------------
void TBranch::SetFirstEntry(Long64_t entry)
{
   //set the first entry number (case of TBranchSTL)
   fFirstEntry = entry;
   fEntries = 0;
   fEntryNumber = entry;
   if( fBasketEntry )
      fBasketEntry[0] = entry;
   for( Int_t i = 0; i < fBranches.GetEntriesFast(); ++i )
      ((TBranch*)fBranches[i])->SetFirstEntry( entry );
}

//______________________________________________________________________________
void TBranch::SetupAddresses()
{
   // -- If the branch address is not set,  we set all addresses starting with
   // the top level parent branch.  

   // Nothing to do for regular branch, the TLeaf already did it.
}

//______________________________________________________________________________
void TBranch::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.

   TFile *file = fTree->GetCurrentFile();
   if (fFileName.Length() == 0) {
      fDirectory = file;

      // Apply to all existing baskets.
      TIter nextb(GetListOfBaskets());
      TBasket *basket;
      while ((basket = (TBasket*)nextb())) {
         basket->SetParent(file);
      }
   }

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