// @(#)root/tree:$Id$
// Author: Rene Brun   04/06/2006

/*************************************************************************
 * 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.             *
 *************************************************************************/

//////////////////////////////////////////////////////////////////////////
//                                                                      //
// TTreeCache                                                           //
//                                                                      //
//  A specialized TFileCacheRead object for a TTree                     //
//  This class acts as a file cache, registering automatically the      //
//  baskets from the branches being processed (TTree::Draw or           //
//  TTree::Process and TSelectors) when in the learning phase.          //
//  The learning phase is by default 100 entries.                       //
//  It can be changed via TTreeCache::SetLearnEntries.                  //
//                                                                      //
//  This cache speeds-up considerably the performance, in particular    //
//  when the Tree is accessed remotely via a high latency network.      //
//                                                                      //
//  The default cache size (10 Mbytes) may be changed via the function  //
//      TTreeCache::SetCacheSize                                        //
//                                                                      //
//  Only the baskets for the requested entry range are put in the cache //
//                                                                      //
//  For each Tree being processed a TTreeCache object is created.       //
//  This object is automatically deleted when the Tree is deleted or    //
//  when the file is deleted.                                           //
//                                                                      //
//  -Special case of a TChain                                           //
//   Once the training is done on the first Tree, the list of branches  //
//   in the cache is kept for the following files.                      //
//                                                                      //
//  -Special case of a TEventlist                                       //
//   if the Tree or TChain has a TEventlist, only the buffers           //
//   referenced by the list are put in the cache.                       //
//                                                                      //
//  The learning period is started or restarted when:
//     - TTree automatically creates a cache. This feature can be
//       controlled with an env. variable or the TTreeCache.Size option.
//     - TTree::SetCacheSize is called with a non-zero size and a cache
//       did not previously exist
//     - TTreeCache::StartLearningPhase is called.
//     - TTree[Cache]::SetEntryRange is called
//          * and the learning is not yet finished
//          * and has not been set to manual
//          * and the new minimun entry is different.
//
//  The learning period is stopped (and prefetching is actually started) when:
//     - TTree[Cache]::StopLearningPhase is called.
//     - An entry outside the 'learning' range is requested
//       The 'learning range is from fEntryMin (default to 0) to
//       fEntryMin + fgLearnEntries (default to 100).
//     - A 'cached' TChain switches over to a new file.
//
//     WHY DO WE NEED the TreeCache when doing data analysis?
//     ======================================================
//
//  When writing a TTree, the branch buffers are kept in memory.
//  A typical branch buffersize (before compression) is typically 32 KBytes.
//  After compression, the zipped buffer may be just a few Kbytes.
//  The branch buffers cannot be much larger in case of Trees with several
//  hundred or thousand branches.
//  When writing, this does not generate a performance problem because branch
//  buffers are always written sequentially and the OS is in general clever enough
//  to flush the data to the output file when a few MBytes of data have to be written.
//  When reading at the contrary, one may hit a performance problem when reading
//  across a network (LAN or WAN) and the network latency is high.
//  For example in a WAN with 10ms latency, reading 1000 buffers of 10 KBytes each
//  with no cache will imply 10s penalty where a local read of the 10 MBytes would
//  take about 1 second.
//  The TreeCache will try to prefetch all the buffers for the selected branches
//  such that instead of transfering 1000 buffers of 10 Kbytes, it will be able
//  to transfer one single large buffer of 10 Mbytes in one single transaction.
//  Not only the TreeCache minimizes the number of transfers, but in addition
//  it can sort the blocks to be read in increasing order such that the file
//  is read sequentially.
//  Systems like xrootd, dCache or httpd take advantage of the TreeCache in
//  reading ahead as much data as they can and return to the application
//  the maximum data specified in the cache and have the next chunk of data ready
//  when the next request comes.
//
//
//     HOW TO USE the TreeCache
//     =========================
//
//  A few use cases are discussed below. A cache may be created with automatic sizing
//  when a TTree is used:
//
//  Caches are created and automatically sized for TTrees when TTreeCache.Size or
//  the environment variable ROOT_TTREECACHE_SIZE is set to a sizing factor.
//
//  But there are many possible configurations where manual control may be wanted.
//  In some applications you know a priori the list of branches to read. In other
//  applications the analysis loop calls several layers of user functions where it
//  is impossible to predict a priori which branches will be used. This
//  is probably the most frequent case. In this case ROOT I/O will flag used
//  branches automatically when a branch buffer is read during the learning phase.
//  The TreeCache interface provides functions to instruct the cache about the used
//  branches if they are known a priori. In the examples below, portions of analysis
//  code are shown. The few statements involving the TreeCache are marked with //<<<
//
//  -------------------
//  1- with TTree::Draw
//  -------------------
//  the TreeCache is automatically used by TTree::Draw. The function knows
//  which branches are used in the query and it puts automatically these branches
//  in the cache. The entry range is also known automatically.
//
//  -------------------------------------
//  2- with TTree::Process and TSelectors
//  -------------------------------------
//  You must enable the cache and tell the system which branches to cache
//  and also specify the entry range. It is important to specify the entry range
//  in case you process only a subset of the events, otherwise you run the risk
//  to store in the cache entries that you do not need.
//
//      --example 2a
//--
//   TTree *T = (TTree*)f->Get("mytree");
//   Long64_t nentries = T->GetEntries();
//   Int_t cachesize = 10000000; //10 MBytes
//   T->SetCacheSize(cachesize); //<<<
//   T->AddBranchToCache("*",kTRUE);    //<<< add all branches to the cache
//   T->Process('myselector.C+");
//   //in the TSelector::Process function we read all branches
//   T->GetEntry(i);
//--      ... here you process your entry
//
//
//      --example 2b
//  in the Process function we read a subset of the branches.
//  Only the branches used in the first entry will be put in the cache
//--
//   TTree *T = (TTree*)f->Get("mytree");
//   //we want to process only the 200 first entries
//   Long64_t nentries=200;
//   int efirst= 0;
//   int elast = efirst+nentries;
//   Int_t cachesize = 10000000; //10 MBytes
//   TTreeCache::SetLearnEntries(1);  //<<< we can take the decision after 1 entry
//   T->SetCacheSize(cachesize);      //<<<
//   T->SetCacheEntryRange(efirst,elast); //<<<
//   T->Process('myselector.C+","",nentries,efirst);
//   // in the TSelector::Process we read only 2 branches
//   TBranch *b1 = T->GetBranch("branch1");
//   b1->GetEntry(i);
//   if (somecondition) return;
//   TBranch *b2 = T->GetBranch("branch2");
//   b2->GetEntry(i);
//      ... here you process your entry
//--
//  ----------------------------
//  3- with your own event loop
//  ----------------------------
//    --example 3a
//      in your analysis loop, you always use 2 branches. You want to prefetch
//      the branch buffers for these 2 branches only.
//--
//   TTree *T = (TTree*)f->Get("mytree");
//   TBranch *b1 = T->GetBranch("branch1");
//   TBranch *b2 = T->GetBranch("branch2");
//   Long64_t nentries = T->GetEntries();
//   Int_t cachesize = 10000000; //10 MBytes
//   T->SetCacheSize(cachesize);     //<<<
//   T->AddBranchToCache(b1,kTRUE);  //<<<add branch1 and branch2 to the cache
//   T->AddBranchToCache(b2,kTRUE);  //<<<
//   T->StopCacheLearningPhase();    //<<<
//   for (Long64_t i=0;i<nentries;i++) {
//      T->LoadTree(i); //<<< important call when calling TBranch::GetEntry after
//      b1->GetEntry(i);
//      if (some condition not met) continue;
//      b2->GetEntry(i);
//      if (some condition not met) continue;
//      //here we read the full event only in some rare cases.
//      //there is no point in caching the other branches as it might be
//      //more economical to read only the branch buffers really used.
//      T->GetEntry(i);
//      .. process the rare but interesting cases.
//      ... here you process your entry
//   }
//--
//   --example 3b
//      in your analysis loop, you always use 2 branches in the main loop.
//      you also call some analysis functions where a few more branches will be read.
//      but you do not know a priori which ones. There is no point in prefetching
//      branches that will be used very rarely.
//--
//   TTree *T = (TTree*)f->Get("mytree");
//   Long64_t nentries = T->GetEntries();
//   Int_t cachesize = 10000000;   //10 MBytes
//   T->SetCacheSize(cachesize);   //<<<
//   T->SetCacheLearnEntries(5);   //<<< we can take the decision after 5 entries
//   TBranch *b1 = T->GetBranch("branch1");
//   TBranch *b2 = T->GetBranch("branch2");
//   for (Long64_t i=0;i<nentries;i++) {
//      T->LoadTree(i);
//      b1->GetEntry(i);
//      if (some condition not met) continue;
//      b2->GetEntry(i);
//      //at this point we may call a user function where a few more branches
//      //will be read conditionally. These branches will be put in the cache
//      //if they have been used in the first 10 entries
//      if (some condition not met) continue;
//      //here we read the full event only in some rare cases.
//      //there is no point in caching the other branches as it might be
//      //more economical to read only the branch buffers really used.
//      T->GetEntry(i);
//      .. process the rare but interesting cases.
//      ... here you process your entry
//   }
//--
//
//
//     SPECIAL CASES WHERE TreeCache should not be activated
//     =====================================================
//
//   When reading only a small fraction of all entries such that not all branch
//   buffers are read, it might be faster to run without a cache.
//
//
//   HOW TO VERIFY That the TreeCache has been used and check its performance
//   ========================================================================
//
//  Once your analysis loop has terminated, you can access/print the number
//  of effective system reads for a given file with a code like
//  (where TFile* f is a pointer to your file)
//
//   printf("Reading %lld bytes in %d transactions\n",f->GetBytesRead(),  f->GetReadCalls());
//
//////////////////////////////////////////////////////////////////////////

#include "TSystem.h"
#include "TEnv.h"
#include "TTreeCache.h"
#include "TChain.h"
#include "TList.h"
#include "TBranch.h"
#include "TEventList.h"
#include "TObjString.h"
#include "TRegexp.h"
#include "TLeaf.h"
#include "TFriendElement.h"
#include "TFile.h"
#include <limits.h>

Int_t TTreeCache::fgLearnEntries = 100;

ClassImp(TTreeCache)

//______________________________________________________________________________
TTreeCache::TTreeCache() : TFileCacheRead(),
   fEntryMin(0),
   fEntryMax(1),
   fEntryCurrent(-1),
   fEntryNext(-1),
   fNbranches(0),
   fNReadOk(0),
   fNReadMiss(0),
   fNReadPref(0),
   fBranches(0),
   fBrNames(0),
   fTree(0),
   fIsLearning(kTRUE),
   fIsManual(kFALSE),
   fFirstBuffer(kTRUE),
   fOneTime(kFALSE),
   fReverseRead(0),
   fFillTimes(0),
   fFirstTime(kTRUE),
   fFirstEntry(-1),
   fReadDirectionSet(kFALSE),
   fEnabled(kTRUE),
   fPrefillType(GetConfiguredPrefillType()),
   fAutoCreated(kFALSE)
{
   // Default Constructor.
}

//______________________________________________________________________________
TTreeCache::TTreeCache(TTree *tree, Int_t buffersize) : TFileCacheRead(tree->GetCurrentFile(),buffersize,tree),
   fEntryMin(0),
   fEntryMax(tree->GetEntriesFast()),
   fEntryCurrent(-1),
   fEntryNext(0),
   fNbranches(0),
   fNReadOk(0),
   fNReadMiss(0),
   fNReadPref(0),
   fBranches(0),
   fBrNames(new TList),
   fTree(tree),
   fIsLearning(kTRUE),
   fIsManual(kFALSE),
   fFirstBuffer(kTRUE),
   fOneTime(kFALSE),
   fReverseRead(0),
   fFillTimes(0),
   fFirstTime(kTRUE),
   fFirstEntry(-1),
   fReadDirectionSet(kFALSE),
   fEnabled(kTRUE),
   fPrefillType(GetConfiguredPrefillType()),
   fAutoCreated(kFALSE)
{
   // Constructor.

   fEntryNext = fEntryMin + fgLearnEntries;
   Int_t nleaves = tree->GetListOfLeaves()->GetEntries();
   fBranches = new TObjArray(nleaves);
}

//______________________________________________________________________________
TTreeCache::~TTreeCache()
{
   // destructor. (in general called by the TFile destructor)

   // Informe the TFile that we have been deleted (in case
   // we are deleted explicitly by legacy user code).
   if (fFile) fFile->SetCacheRead(0, fTree);

   delete fBranches;
   if (fBrNames) {fBrNames->Delete(); delete fBrNames; fBrNames=0;}
}

//_____________________________________________________________________________
Int_t TTreeCache::AddBranch(TBranch *b, Bool_t subbranches /*= kFALSE*/)
{
   //add a branch to the list of branches to be stored in the cache
   //this function is called by TBranch::GetBasket
   // Returns  0 branch added or already included
   //         -1 on error

   if (!fIsLearning) {
      return -1;
   }

   // Reject branch that are not from the cached tree.
   if (!b || fTree->GetTree() != b->GetTree()) return -1;

   // Is this the first addition of a branch (and we are learning and we are in
   // the expected TTree), then prefill the cache.  (We expect that in future
   // release the Prefill-ing will be the default so we test for that inside the
   // LearnPrefill call).
   if (fNbranches == 0 && fEntryMin >= 0 && b->GetReadEntry() == fEntryMin) LearnPrefill();

   //Is branch already in the cache?
   Bool_t isNew = kTRUE;
   for (int i=0;i<fNbranches;i++) {
      if (fBranches->UncheckedAt(i) == b) {isNew = kFALSE; break;}
   }
   if (isNew) {
      fTree = b->GetTree();
      fBranches->AddAtAndExpand(b, fNbranches);
      fBrNames->Add(new TObjString(b->GetName()));
      fNbranches++;
      if (gDebug > 0) printf("Entry: %lld, registering branch: %s\n",b->GetTree()->GetReadEntry(),b->GetName());
   }

   // process subbranches
   Int_t res = 0;
   if (subbranches) {
      TObjArray *lb = b->GetListOfBranches();
      Int_t nb = lb->GetEntriesFast();
      for (Int_t j = 0; j < nb; j++) {
         TBranch* branch = (TBranch*) lb->UncheckedAt(j);
         if (!branch) continue;
         if (AddBranch(branch, subbranches)<0) {
            res = -1;
         }
      }
   }
   return res;
}


//_____________________________________________________________________________
Int_t TTreeCache::AddBranch(const char *bname, Bool_t subbranches /*= kFALSE*/)
{
   // Add a branch to the list of branches to be stored in the cache
   // this is to be used by user (thats why we pass the name of the branch).
   // It works in exactly the same way as TTree::SetBranchStatus so you
   // probably want to look over ther for details about the use of bname
   // with regular expressions.
   // The branches are taken with respect to the Owner of this TTreeCache
   // (i.e. the original Tree)
   // NB: if bname="*" all branches are put in the cache and the learning phase stopped
   // Returns  0 branch added or already included
   //         -1 on error

   TBranch *branch, *bcount;
   TLeaf *leaf, *leafcount;

   Int_t i;
   Int_t nleaves = (fTree->GetListOfLeaves())->GetEntriesFast();
   TRegexp re(bname,kTRUE);
   Int_t nb = 0;
   Int_t res = 0;

   // first pass, loop on all branches
   // for leafcount branches activate/deactivate in function of status
   Bool_t all = kFALSE;
   if (!strcmp(bname,"*")) all = kTRUE;
   for (i=0;i<nleaves;i++)  {
      leaf = (TLeaf*)(fTree->GetListOfLeaves())->UncheckedAt(i);
      branch = (TBranch*)leaf->GetBranch();
      TString s = branch->GetName();
      if (!all) { //Regexp gives wrong result for [] in name
         TString longname;
         longname.Form("%s.%s",fTree->GetName(),branch->GetName());
         if (strcmp(bname,branch->GetName())
             && longname != bname
             && s.Index(re) == kNPOS) continue;
      }
      nb++;
      if (AddBranch(branch, subbranches)<0) {
         res = -1;
      }
      leafcount = leaf->GetLeafCount();
      if (leafcount && !all) {
         bcount = leafcount->GetBranch();
         if (AddBranch(bcount, subbranches)<0) {
            res = -1;
         }
      }
   }
   if (nb==0 && strchr(bname,'*')==0) {
      branch = fTree->GetBranch(bname);
      if (branch) {
         if (AddBranch(branch, subbranches)<0) {
            res = -1;
         }
         ++nb;
      }
   }

   //search in list of friends
   UInt_t foundInFriend = 0;
   if (fTree->GetListOfFriends()) {
      TIter nextf(fTree->GetListOfFriends());
      TFriendElement *fe;
      TString name;
      while ((fe = (TFriendElement*)nextf())) {
         TTree *t = fe->GetTree();
         if (t==0) continue;

         // If the alias is present replace it with the real name.
         char *subbranch = (char*)strstr(bname,fe->GetName());
         if (subbranch!=bname) subbranch = 0;
         if (subbranch) {
            subbranch += strlen(fe->GetName());
            if ( *subbranch != '.' ) subbranch = 0;
            else subbranch ++;
         }
         if (subbranch) {
            name.Form("%s.%s",t->GetName(),subbranch);
            if (AddBranch(name, subbranches)<0) {
               res = -1;
            }
            ++foundInFriend;
         }
      }
   }
   if (!nb && !foundInFriend) {
      if (gDebug > 0) printf("AddBranch: unknown branch -> %s \n", bname);
      Error("AddBranch", "unknown branch -> %s", bname);
      return -1;
   }
   //if all branches are selected stop the learning phase
   if (*bname == '*') {
      fEntryNext = -1; // We are likely to have change the set of branches, so for the [re-]reading of the cluster.
      StopLearningPhase();
   }
   return res;
}

//_____________________________________________________________________________
Int_t TTreeCache::DropBranch(TBranch *b, Bool_t subbranches /*= kFALSE*/)
{
   // Remove a branch to the list of branches to be stored in the cache
   // this function is called by TBranch::GetBasket.
   // Returns  0 branch dropped or not in cache
   //         -1 on error

   if (!fIsLearning) {
      return -1;
   }

   // Reject branch that are not from the cached tree.
   if (!b || fTree->GetTree() != b->GetTree()) return -1;

   //Is branch already in the cache?
   if (fBranches->Remove(b)) {
      --fNbranches;
      if (gDebug > 0) printf("Entry: %lld, un-registering branch: %s\n",b->GetTree()->GetReadEntry(),b->GetName());
   }
   fBrNames->Remove(fBrNames->FindObject(b->GetName()));

   // process subbranches
   Int_t res = 0;
   if (subbranches) {
      TObjArray *lb = b->GetListOfBranches();
      Int_t nb = lb->GetEntriesFast();
      for (Int_t j = 0; j < nb; j++) {
         TBranch* branch = (TBranch*) lb->UncheckedAt(j);
         if (!branch) continue;
         if (DropBranch(branch, subbranches)<0) {
            res = -1;
         }
      }
   }
   return res;
}


//_____________________________________________________________________________
Int_t TTreeCache::DropBranch(const char *bname, Bool_t subbranches /*= kFALSE*/)
{
   // Remove a branch to the list of branches to be stored in the cache
   // this is to be used by user (thats why we pass the name of the branch).
   // It works in exactly the same way as TTree::SetBranchStatus so you
   // probably want to look over ther for details about the use of bname
   // with regular expresions.
   // The branches are taken with respect to the Owner of this TTreeCache
   // (i.e. the original Tree)
   // NB: if bname="*" all branches are put in the cache and the learning phase stopped
   // Returns  0 branch dropped or not in cache
   //         -1 on error

   TBranch *branch, *bcount;
   TLeaf *leaf, *leafcount;

   Int_t i;
   Int_t nleaves = (fTree->GetListOfLeaves())->GetEntriesFast();
   TRegexp re(bname,kTRUE);
   Int_t nb = 0;
   Int_t res = 0;

   // first pass, loop on all branches
   // for leafcount branches activate/deactivate in function of status
   Bool_t all = kFALSE;
   if (!strcmp(bname,"*")) all = kTRUE;
   for (i=0;i<nleaves;i++)  {
      leaf = (TLeaf*)(fTree->GetListOfLeaves())->UncheckedAt(i);
      branch = (TBranch*)leaf->GetBranch();
      TString s = branch->GetName();
      if (!all) { //Regexp gives wrong result for [] in name
         TString longname;
         longname.Form("%s.%s",fTree->GetName(),branch->GetName());
         if (strcmp(bname,branch->GetName())
             && longname != bname
             && s.Index(re) == kNPOS) continue;
      }
      nb++;
      if (DropBranch(branch, subbranches)<0) {
         res = -1;
      }
      leafcount = leaf->GetLeafCount();
      if (leafcount && !all) {
         bcount = leafcount->GetBranch();
         if (DropBranch(bcount, subbranches)<0) {
            res = -1;
         }
      }
   }
   if (nb==0 && strchr(bname,'*')==0) {
      branch = fTree->GetBranch(bname);
      if (branch) {
         if (DropBranch(branch, subbranches)<0) {
            res = -1;
         }
         ++nb;
      }
   }

   //search in list of friends
   UInt_t foundInFriend = 0;
   if (fTree->GetListOfFriends()) {
      TIter nextf(fTree->GetListOfFriends());
      TFriendElement *fe;
      TString name;
      while ((fe = (TFriendElement*)nextf())) {
         TTree *t = fe->GetTree();
         if (t==0) continue;

         // If the alias is present replace it with the real name.
         char *subbranch = (char*)strstr(bname,fe->GetName());
         if (subbranch!=bname) subbranch = 0;
         if (subbranch) {
            subbranch += strlen(fe->GetName());
            if ( *subbranch != '.' ) subbranch = 0;
            else subbranch ++;
         }
         if (subbranch) {
            name.Form("%s.%s",t->GetName(),subbranch);
            if (DropBranch(name, subbranches)<0) {
               res = -1;
            }
            ++foundInFriend;
         }
      }
   }
   if (!nb && !foundInFriend) {
      if (gDebug > 0) printf("DropBranch: unknown branch -> %s \n", bname);
      Error("DropBranch", "unknown branch -> %s", bname);
      return -1;
   }
   //if all branches are selected stop the learning phase
   if (*bname == '*') {
      fEntryNext = -1; // We are likely to have change the set of branches, so for the [re-]reading of the cluster.
   }
   return res;
}

//_____________________________________________________________________________
Bool_t TTreeCache::FillBuffer()
{
   // Fill the cache buffer with the branches in the cache.

   if (fNbranches <= 0) return kFALSE;
   TTree *tree = ((TBranch*)fBranches->UncheckedAt(0))->GetTree();
   Long64_t entry = tree->GetReadEntry();
   Long64_t fEntryCurrentMax = 0;

   if (fEnablePrefetching) { // Prefetching mode
      if (fIsLearning) { //  Learning mode
         entry = 0;
      }
      if (fFirstTime) {
         //try to detect if it is normal or reverse read
         fFirstEntry = entry;
      }
      else {
         if (fFirstEntry == entry) return kFALSE;
         // Set the read direction
         if (!fReadDirectionSet) {
            if (entry < fFirstEntry) {
               fReverseRead = kTRUE;
               fReadDirectionSet = kTRUE;
            }
            else if (entry > fFirstEntry) {
               fReverseRead =kFALSE;
               fReadDirectionSet = kTRUE;
            }
         }

         if (fReverseRead) {
            // Reverse reading with prefetching
            if (fEntryCurrent >0 && entry < fEntryNext) {
               // We can prefetch the next buffer
               if (entry >= fEntryCurrent) {
                  entry = fEntryCurrent - tree->GetAutoFlush() * fFillTimes;
               }
               if (entry < 0) entry = 0;
            }
            else if (fEntryCurrent >= 0) {
               // We are still reading from the oldest buffer, no need to prefetch a new one
               return kFALSE;
            }
            if (entry < 0) return kFALSE;
            fFirstBuffer = !fFirstBuffer;
         }
         else {
            // Normal reading with prefetching
            if (fEnablePrefetching) {
               if (entry < 0 && fEntryNext > 0) {
                  entry = fEntryCurrent;
               } else if (entry >= fEntryCurrent) {
                  if (entry < fEntryNext) {
                     entry = fEntryNext;
                  }
               }
               else {
                  // We are still reading from the oldest buffer,
                  // no need to prefetch a new one
                  return kFALSE;
               }
               fFirstBuffer = !fFirstBuffer;
            }
         }
      }
   }

   // If the entry is in the range we previously prefetched, there is
   // no point in retrying.   Note that this will also return false
   // during the training phase (fEntryNext is then set intentional to
   // the end of the training phase).
   if (fEntryCurrent <= entry && entry < fEntryNext) return kFALSE;

   // Triggered by the user, not the learning phase
   if (entry == -1)  entry = 0;

   fEntryCurrentMax = fEntryCurrent;
   TTree::TClusterIterator clusterIter = tree->GetClusterIterator(entry);
   fEntryCurrent = clusterIter();
   fEntryNext = clusterIter.GetNextEntry();

   if (fEntryCurrent < fEntryMin) fEntryCurrent = fEntryMin;
   if (fEntryMax <= 0) fEntryMax = tree->GetEntries();
   if (fEntryNext > fEntryMax) fEntryNext = fEntryMax;

   if ( fEnablePrefetching ) {
      if ( entry == fEntryMax ) {
         // We are at the end, no need to do anything else
         return kFALSE;
      }
   }

   // Check if owner has a TEventList set. If yes we optimize for this
   // Special case reading only the baskets containing entries in the
   // list.
   TEventList *elist = fTree->GetEventList();
   Long64_t chainOffset = 0;
   if (elist) {
      if (fTree->IsA() ==TChain::Class()) {
         TChain *chain = (TChain*)fTree;
         Int_t t = chain->GetTreeNumber();
         chainOffset = chain->GetTreeOffset()[t];
      }
   }

   //clear cache buffer
   Int_t fNtotCurrentBuf = 0;
   if (fEnablePrefetching){ //prefetching mode
      if (fFirstBuffer) {
         TFileCacheRead::Prefetch(0,0);
         fNtotCurrentBuf = fNtot;
      }
      else {
         TFileCacheRead::SecondPrefetch(0,0);
         fNtotCurrentBuf = fBNtot;
      }
   }
   else {
      TFileCacheRead::Prefetch(0,0);
      fNtotCurrentBuf = fNtot;
   }

   //store baskets
   Int_t clusterIterations = 0;
   Long64_t minEntry = fEntryCurrent;
   Int_t prevNtot;
   Int_t minBasket = 0;  // We will use this to avoid re-checking the first baskets in the 2nd (or more) run in the while loop.
   Long64_t maxReadEntry = minEntry; // If we are stopped before the end of the 2nd pass, this marker will where we need to start next time.
   do {
      prevNtot = fNtotCurrentBuf;
      Int_t nextMinBasket = INT_MAX;
      UInt_t pass = 0;
      while (pass < 2) {
         // The first pass we add one basket per branches.
         // then in the second pass we add the other baskets of the cluster.
         // This is to support the case where the cache is too small to hold a full cluster.
         ++pass;
         for (Int_t i=0;i<fNbranches;i++) {
            TBranch *b = (TBranch*)fBranches->UncheckedAt(i);
            if (b->GetDirectory()==0) continue;
            if (b->GetDirectory()->GetFile() != fFile) continue;
            Int_t nb = b->GetMaxBaskets();
            Int_t *lbaskets   = b->GetBasketBytes();
            Long64_t *entries = b->GetBasketEntry();
            if (!lbaskets || !entries) continue;
            //we have found the branch. We now register all its baskets
            //from the requested offset to the basket below fEntrymax
            Int_t blistsize = b->GetListOfBaskets()->GetSize();
            Int_t j=minBasket;  // We need this out of the loop so we can find out how far we went.
            Bool_t firstBasketSeen = kFALSE;
            for (;j<nb;j++) {
               // This basket has already been read, skip it
               if (j<blistsize && b->GetListOfBaskets()->UncheckedAt(j)) continue;

               Long64_t pos = b->GetBasketSeek(j);
               Int_t len = lbaskets[j];
               if (pos <= 0 || len <= 0) continue;
               if (len > fBufferSizeMin) {
                  // Do not cache a basket if it is bigger than the cache size!
                  continue;
               }
               //important: do not try to read fEntryNext, otherwise you jump to the next autoflush
               if (entries[j] >= fEntryNext) break; // break out of the for each branch loop.
               if (entries[j] < minEntry && (j<nb-1 && entries[j+1] <= minEntry)) continue;
               if (elist) {
                  Long64_t emax = fEntryMax;
                  if (j<nb-1) emax = entries[j+1]-1;
                  if (!elist->ContainsRange(entries[j]+chainOffset,emax+chainOffset)) continue;
               }
               if (pass==2 && !firstBasketSeen) {
                  // Okay, this has already been requested in the first pass.
                  firstBasketSeen = kTRUE;
                  continue;
               }
               fNReadPref++;

               if ( (fNtotCurrentBuf+len) > fBufferSizeMin ) {
                  // Humm ... we are going to go over the requested size.
                  if (clusterIterations > 0) {
                     // We already have a full cluster and now we would go over the requested
                     // size, let's stop caching (and make sure we start next time from the
                     // end of the previous cluster).
                     if (gDebug > 5) {
                        Info("FillBuffer","Breaking early because %d is greater than %d at cluster iteration %d will restart at %lld",(fNtotCurrentBuf+len), fBufferSizeMin, clusterIterations,minEntry);
                     }
                     fEntryNext = minEntry;
                     break;
                  } else {
                     if (pass == 1) {
                        if ( (fNtotCurrentBuf+len) > 4*fBufferSizeMin ) {
                           // Okay, so we have not even made one pass and we already have
                           // accumulated request for more than twice the memory size ...
                           // So stop for now, and will restart at the same point, hoping
                           // that the basket will still be in memory and not asked again ..
                           fEntryNext = maxReadEntry;
                           if (gDebug > 5) {
                              Info("FillBuffer","Breaking early because %d is greater than 2*%d at cluster iteration %d pass %d will restart at %lld",(fNtotCurrentBuf+len), fBufferSizeMin, clusterIterations,pass,fEntryNext);
                           }
                           break;
                        }
                     } else {
                        // We have made one pass through the branches and thus already
                        // requested one basket per branch, let's stop prefetching
                        // now.
                        if ( (fNtotCurrentBuf+len) > 2*fBufferSizeMin ) {
                           fEntryNext = maxReadEntry;
                           if (gDebug > 5) {
                              Info("FillBuffer","Breaking early because %d is greater than 2*%d at cluster iteration %d pass %d will restart at %lld",(fNtotCurrentBuf+len), fBufferSizeMin, clusterIterations,pass,fEntryNext);
                           }
                           break;
                        }
                     }
                  }
               }
               if (fEnablePrefetching){
                  if (fFirstBuffer) {
                     TFileCacheRead::Prefetch(pos,len);
                     fNtotCurrentBuf = fNtot;
                  }
                  else {
                     TFileCacheRead::SecondPrefetch(pos,len);
                     fNtotCurrentBuf = fBNtot;
                  }
               }
               else {
                  TFileCacheRead::Prefetch(pos,len);
                  fNtotCurrentBuf = fNtot;
               }
               if ( ( j < (nb-1) ) && entries[j+1] > maxReadEntry ) {
                  maxReadEntry = entries[j+1];
               }
               if (fNtotCurrentBuf > 4*fBufferSizeMin) {
                  // Humm something wrong happened.
                  Warning("FillBuffer","There is more data in this cluster (starting at entry %lld to %lld, current=%lld) than usual ... with %d %.3f%% of the branches we already have %d bytes (instead of %d)",
                          fEntryCurrent,fEntryNext, entries[j], i, (100.0*i) / ((float)fNbranches), fNtotCurrentBuf,fBufferSizeMin);

               }
               if (pass==1) {
                  // In the first pass, we record one basket per branch and move on to the next branch.
                  break;
               }
            }

            if (j < nextMinBasket) nextMinBasket = j;
            if (gDebug > 0) printf("Entry: %lld, registering baskets branch %s, fEntryNext=%lld, fNseek=%d, fNtotCurrentBuf=%d\n",minEntry,((TBranch*)fBranches->UncheckedAt(i))->GetName(),fEntryNext,fNseek,fNtotCurrentBuf);
         }
      } // loop for the 2 passes.
      clusterIterations++;

      minEntry = clusterIter.Next();
      if (fIsLearning) {
         fFillTimes++;
      }

      // Continue as long as we still make progress (prevNtot < fNtotCurrentBuf), that the next entry range to be looked at,
      // which start at 'minEntry', is not past the end of the requested range (minEntry < fEntryMax)
      // and we guess that we not going to go over the requested amount of memory by asking for another set
      // of entries (fBufferSizeMin > ((Long64_t)fNtotCurrentBuf*(clusterIterations+1))/clusterIterations).
      // fNtotCurrentBuf / clusterIterations is the average size we are accumulated so far at each loop.
      // and thus (fNtotCurrentBuf / clusterIterations) * (clusterIterations+1) is a good guess at what the next total size
      // would be if we run the loop one more time.   fNtotCurrentBuf and clusterIterations are Int_t but can sometimes
      // be 'large' (i.e. 30Mb * 300 intervals) and can overflow the numercial limit of Int_t (i.e. become
      // artificially negative).   To avoid this issue we promote fNtotCurrentBuf to a long long (64 bits rather than 32 bits)
      if (!((fBufferSizeMin > ((Long64_t)fNtotCurrentBuf*(clusterIterations+1))/clusterIterations) && (prevNtot < fNtotCurrentBuf) && (minEntry < fEntryMax)))
         break;

      //for the reverse reading case
      if (!fIsLearning && fReverseRead){
         if (clusterIterations >= fFillTimes)
            break;
         if (minEntry >= fEntryCurrentMax && fEntryCurrentMax >0)
            break;
      }
      minBasket = nextMinBasket;
      fEntryNext = clusterIter.GetNextEntry();
      if (fEntryNext > fEntryMax) fEntryNext = fEntryMax;
   } while (kTRUE);

   if (fEnablePrefetching) {
      if (fIsLearning) {
         fFirstBuffer = !fFirstBuffer;
      }
      if (!fIsLearning && fFirstTime){
         // First time we add autoFlush entries , after fFillTimes * autoFlush
         // only in reverse prefetching mode
         fFirstTime = kFALSE;
      }
   }
   fIsLearning = kFALSE;
   return kTRUE;
}

//______________________________________________________________________________
TTreeCache::EPrefillType TTreeCache::GetConfiguredPrefillType() const
{
   // Return the desired prefill type from the environment or resource variable
   // 0 - No prefill
   // 1 - All branches

   const char *stcp;
   Int_t s = 0;

   if (!(stcp = gSystem->Getenv("ROOT_TTREECACHE_PREFILL")) || !*stcp) {
      s = gEnv->GetValue("TTreeCache.Prefill", 1);
   } else {
      s = TString(stcp).Atoi();
   }

   return static_cast<TTreeCache::EPrefillType>(s);
}

//_____________________________________________________________________________
Double_t TTreeCache::GetEfficiency() const
{
   // Give the total efficiency of the cache... defined as the ratio
   // of blocks found in the cache vs. the number of blocks prefetched
   // ( it could be more than 1 if we read the same block from the cache more
   //   than once )
   // Note: This should eb used at the end of the processing or we will
   //       get uncomplete stats

   if ( !fNReadPref )
      return 0;

   return ((Double_t)fNReadOk / (Double_t)fNReadPref);
}

//_____________________________________________________________________________
Double_t TTreeCache::GetEfficiencyRel() const
{
   // This will indicate a sort of relative efficiency... a ratio of the
   // reads found in the cache to the number of reads so far

   if ( !fNReadOk && !fNReadMiss )
      return 0;

   return ((Double_t)fNReadOk / (Double_t)(fNReadOk + fNReadMiss));
}

//_____________________________________________________________________________
Int_t TTreeCache::GetLearnEntries()
{
   //static function returning the number of entries used to train the cache
   //see SetLearnEntries

   return fgLearnEntries;
}

//_____________________________________________________________________________
void TTreeCache::Print(Option_t *option) const
{
   // Print cache statistics, like
   //   ******TreeCache statistics for file: cms2.root ******
   //   Number of branches in the cache ...: 1093
   //   Cache Efficiency ..................: 0.997372
   //   Cache Efficiency Rel...............: 1.000000
   //   Learn entries......................: 100
   //   Reading............................: 72761843 bytes in 7 transactions
   //   Readahead..........................: 256000 bytes with overhead = 0 bytes
   //   Average transaction................: 10394.549000 Kbytes
   //   Number of blocks in current cache..: 210, total size: 6280352
   //
   // if option = "a" the list of blocks in the cache is printed
   // see also class TTreePerfStats.
   // if option contains 'cachedbranches', the list of branches being
   // cached is printed.

   TString opt = option;
   opt.ToLower();
   printf("******TreeCache statistics for tree: %s in file: %s ******\n",fTree ? fTree->GetName() : "no tree set",fFile ? fFile->GetName() : "no file set");
   if (fNbranches <= 0) return;
   printf("Number of branches in the cache ...: %d\n",fNbranches);
   printf("Cache Efficiency ..................: %f\n",GetEfficiency());
   printf("Cache Efficiency Rel...............: %f\n",GetEfficiencyRel());
   printf("Learn entries......................: %d\n",TTreeCache::GetLearnEntries());
   if ( opt.Contains("cachedbranches") ) {
      opt.ReplaceAll("cachedbranches","");
      printf("Cached branches....................:\n");
      const TObjArray *cachedBranches = this->GetCachedBranches();
      Int_t nbranches = cachedBranches->GetEntriesFast();
      for (Int_t i = 0; i < nbranches; ++i) {
         TBranch* branch = (TBranch*) cachedBranches->UncheckedAt(i);
         printf("Branch name........................: %s\n",branch->GetName());
      }
   }
   TFileCacheRead::Print(opt);
}


//_____________________________________________________________________________
Int_t TTreeCache::ReadBufferNormal(char *buf, Long64_t pos, Int_t len){

  //Old method ReadBuffer before the addition of the prefetch mechanism

   //Is request already in the cache?
   if (TFileCacheRead::ReadBuffer(buf,pos,len) == 1){
      fNReadOk++;
      return 1;
   }

   //not found in cache. Do we need to fill the cache?
   Bool_t bufferFilled = FillBuffer();
   if (bufferFilled) {
      Int_t res = TFileCacheRead::ReadBuffer(buf,pos,len);

      if (res == 1)
         fNReadOk++;
      else if (res == 0)
         fNReadMiss++;

      return res;
   }
   fNReadMiss++;

   return 0;
}


//_____________________________________________________________________________
Int_t TTreeCache::ReadBufferPrefetch(char *buf, Long64_t pos, Int_t len){

   // Used to read a chunk from a block previously fetched. It will call FillBuffer
   // even if the cache lookup succeeds, because it will try to prefetch the next block
   // as soon as we start reading from the current block.

   if (TFileCacheRead::ReadBuffer(buf, pos, len) == 1){
      //call FillBuffer to prefetch next block if necessary
      //(if we are currently reading from the last block available)
      FillBuffer();
      fNReadOk++;
      return 1;
   }

   //keep on prefetching until request is satisfied
   // try to prefetch a couple of times and if request is still not satisfied then
   // fall back to normal reading without prefetching for the current request
   Int_t counter = 0;
   while (1) {
      if(TFileCacheRead::ReadBuffer(buf, pos, len)) {
         break;
      }
      FillBuffer();
      fNReadMiss++;
      counter++;
      if (counter>1) {
        return 0;
      }
   }

   fNReadOk++;
   return 1;
}

//_____________________________________________________________________________
Int_t TTreeCache::ReadBuffer(char *buf, Long64_t pos, Int_t len)
{
   // Read buffer at position pos if the request is in the list of
   // prefetched blocks read from fBuffer.
   // Otherwise try to fill the cache from the list of selected branches,
   // and recheck if pos is now in the list.
   // Returns
   //    -1 in case of read failure,
   //     0 in case not in cache,
   //     1 in case read from cache.
   // This function overloads TFileCacheRead::ReadBuffer.

   if (!fEnabled) return 0;

   if (fEnablePrefetching)
      return TTreeCache::ReadBufferPrefetch(buf, pos, len);
   else
      return TTreeCache::ReadBufferNormal(buf, pos, len);
}

//_____________________________________________________________________________
void TTreeCache::ResetCache()
{
   // This will simply clear the cache
   TFileCacheRead::Prefetch(0,0);

   if (fEnablePrefetching) {
      fFirstTime = kTRUE;
      TFileCacheRead::SecondPrefetch(0, 0);
   }
}


//_____________________________________________________________________________
Int_t TTreeCache::SetBufferSize(Int_t buffersize)
{
   // Change the underlying buffer size of the cache.
   // If the change of size means some cache content is lost, or if the buffer
   // is now larger, setup for a cache refill the next time there is a read
   // Returns  0 if the buffer content is still available
   //          1 if some or all of the buffer content has been made unavailable
   //         -1 on error

   Int_t prevsize = GetBufferSize();
   Int_t res = TFileCacheRead::SetBufferSize(buffersize);
   if (res < 0) {
      return res;
   }

   if (res == 0 && buffersize <= prevsize) {
      return res;
   }

   // if content was removed from the buffer, or the buffer was enlarged then
   // empty the prefetch lists and prime to fill the cache again

   TFileCacheRead::Prefetch(0,0);
   if (fEnablePrefetching) {
      TFileCacheRead::SecondPrefetch(0, 0);
   }

   fEntryCurrent = -1;
   if (!fIsLearning) {
      fEntryNext = -1;
   }

   return 1;
}


//_____________________________________________________________________________
void TTreeCache::SetEntryRange(Long64_t emin, Long64_t emax)
{
   // Set the minimum and maximum entry number to be processed
   // this information helps to optimize the number of baskets to read
   // when prefetching the branch buffers.

   // This is called by TTreePlayer::Process in an automatic way...
   // don't restart it if the user has specified the branches.
   Bool_t needLearningStart = (fEntryMin != emin) && fIsLearning && !fIsManual;

   fEntryMin  = emin;
   fEntryMax  = emax;
   fEntryNext  = fEntryMin + fgLearnEntries * (fIsLearning && !fIsManual);
   if (gDebug > 0)
      Info("SetEntryRange", "fEntryMin=%lld, fEntryMax=%lld, fEntryNext=%lld",
                             fEntryMin, fEntryMax, fEntryNext);

   if (needLearningStart) {
      // Restart learning
      StartLearningPhase();
   }
}

//_____________________________________________________________________________
void TTreeCache::SetFile(TFile *file, TFile::ECacheAction action)
{
   // Overload to make sure that the object specific

   // The infinite recursion is 'broken' by the fact that
   // TFile::SetCacheRead remove the entry from fCacheReadMap _before_
   // calling SetFile (and also by setting fFile to zero before the calling).
   if (fFile) {
      TFile *prevFile = fFile;
      fFile = 0;
      prevFile->SetCacheRead(0, fTree, action);
   }
   TFileCacheRead::SetFile(file, action);
}

//_____________________________________________________________________________
void TTreeCache::SetLearnEntries(Int_t n)
{
   // Static function to set the number of entries to be used in learning mode
   // The default value for n is 10. n must be >= 1

   if (n < 1) n = 1;
   fgLearnEntries = n;
}

//_____________________________________________________________________________
void TTreeCache::SetLearnPrefill(TTreeCache::EPrefillType type /* = kNoPrefill */)
{
   // Set whether the learning period is started with a prefilling of the
   // cache and which type of prefilling is used.
   // The two value currently supported are:
   //   TTreeCache::kNoPrefill    disable the prefilling
   //   TTreeCache::kAllBranches  fill the cache with baskets from all branches.
   // The default prefilling behavior can be controlled by setting
   // TTreeCache.Prefill or the environment variable ROOT_TTREECACHE_PREFILL.

   fPrefillType = type;
}

//_____________________________________________________________________________
void TTreeCache::StartLearningPhase()
{
   // The name should be enough to explain the method.
   // The only additional comments is that the cache is cleaned before
   // the new learning phase.

   fIsLearning = kTRUE;
   fIsManual = kFALSE;
   fNbranches  = 0;
   if (fBrNames) fBrNames->Delete();
   fIsTransferred = kFALSE;
   fEntryCurrent = -1;
}

//_____________________________________________________________________________
void TTreeCache::StopLearningPhase()
{
   // This is the counterpart of StartLearningPhase() and can be used to stop
   // the learning phase. It's useful when the user knows exactly what branches
   // they are going to use.
   // For the moment it's just a call to FillBuffer() since that method
   // will create the buffer lists from the specified branches.

   if (fIsLearning) {
      // This will force FillBuffer to read the buffers.
      fEntryNext = -1;
      fIsLearning = kFALSE;
   }
   fIsManual = kTRUE;

   //fill the buffers only once during learning
   if (fEnablePrefetching && !fOneTime) {
      fIsLearning = kTRUE;
      FillBuffer();
      fOneTime = kTRUE;
   }
}

//_____________________________________________________________________________
void TTreeCache::UpdateBranches(TTree *tree)
{
   // Update pointer to current Tree and recompute pointers to the branches in the cache.


   fTree = tree;

   fEntryMin  = 0;
   fEntryMax  = fTree->GetEntries();

   fEntryCurrent = -1;

   if (fBrNames->GetEntries() == 0 && fIsLearning) {
      // We still need to learn.
      fEntryNext = fEntryMin + fgLearnEntries;
   } else {
      // We learnt from a previous file.
      fIsLearning = kFALSE;
      fEntryNext = -1;
   }
   fNbranches = 0;

   TIter next(fBrNames);
   TObjString *os;
   while ((os = (TObjString*)next())) {
      TBranch *b = fTree->GetBranch(os->GetName());
      if (!b) {
         continue;
      }
      fBranches->AddAt(b, fNbranches);
      fNbranches++;
   }
}

//_____________________________________________________________________________
void TTreeCache::LearnPrefill()
{
   // Perform an initial prefetch, attempting to read as much of the learning
   // phase baskets for all branches at once

   // This is meant for the learning phase
   if (!fIsLearning) return;

   // This should be called before reading entries, otherwise we'll
   // always exit here, since TBranch adds itself before reading
   if (fNbranches > 0) return;

   // Is the LearnPrefill enabled (using an Int_t here to allow for future
   // extension to alternative Prefilling).
   if (fPrefillType == kNoPrefill) return;

   // Force only the learn entries to be cached by temporarily setting min/max
   // to the learning phase entry range
   // But save all the old values, so we can restore everything to how it was
   Long64_t eminOld = fEntryMin;
   Long64_t emaxOld = fEntryMax;
   Long64_t ecurrentOld = fEntryCurrent;
   Long64_t enextOld = fEntryNext;

   fEntryMin = fEntryCurrent;
   fEntryMax = fEntryNext;

   // Add all branches to be cached. This also sets fIsManual, stops learning,
   // and makes fEntryNext = -1 (which forces a cache fill, which is good)
   AddBranch("*");
   fIsManual = kFALSE; // AddBranch sets fIsManual, so we reset it

   // Now, fill the buffer with the learning phase entry range
   FillBuffer();

   // Leave everything the way we found it
   fIsLearning = kTRUE;
   DropBranch("*"); // This doesn't work unless we're already learning

   // Restore entry values
   fEntryMin = eminOld;
   fEntryMax = emaxOld;
   fEntryCurrent = ecurrentOld;
   fEntryNext = enextOld;
}
 TTreeCache.cxx:1
 TTreeCache.cxx:2
 TTreeCache.cxx:3
 TTreeCache.cxx:4
 TTreeCache.cxx:5
 TTreeCache.cxx:6
 TTreeCache.cxx:7
 TTreeCache.cxx:8
 TTreeCache.cxx:9
 TTreeCache.cxx:10
 TTreeCache.cxx:11
 TTreeCache.cxx:12
 TTreeCache.cxx:13
 TTreeCache.cxx:14
 TTreeCache.cxx:15
 TTreeCache.cxx:16
 TTreeCache.cxx:17
 TTreeCache.cxx:18
 TTreeCache.cxx:19
 TTreeCache.cxx:20
 TTreeCache.cxx:21
 TTreeCache.cxx:22
 TTreeCache.cxx:23
 TTreeCache.cxx:24
 TTreeCache.cxx:25
 TTreeCache.cxx:26
 TTreeCache.cxx:27
 TTreeCache.cxx:28
 TTreeCache.cxx:29
 TTreeCache.cxx:30
 TTreeCache.cxx:31
 TTreeCache.cxx:32
 TTreeCache.cxx:33
 TTreeCache.cxx:34
 TTreeCache.cxx:35
 TTreeCache.cxx:36
 TTreeCache.cxx:37
 TTreeCache.cxx:38
 TTreeCache.cxx:39
 TTreeCache.cxx:40
 TTreeCache.cxx:41
 TTreeCache.cxx:42
 TTreeCache.cxx:43
 TTreeCache.cxx:44
 TTreeCache.cxx:45
 TTreeCache.cxx:46
 TTreeCache.cxx:47
 TTreeCache.cxx:48
 TTreeCache.cxx:49
 TTreeCache.cxx:50
 TTreeCache.cxx:51
 TTreeCache.cxx:52
 TTreeCache.cxx:53
 TTreeCache.cxx:54
 TTreeCache.cxx:55
 TTreeCache.cxx:56
 TTreeCache.cxx:57
 TTreeCache.cxx:58
 TTreeCache.cxx:59
 TTreeCache.cxx:60
 TTreeCache.cxx:61
 TTreeCache.cxx:62
 TTreeCache.cxx:63
 TTreeCache.cxx:64
 TTreeCache.cxx:65
 TTreeCache.cxx:66
 TTreeCache.cxx:67
 TTreeCache.cxx:68
 TTreeCache.cxx:69
 TTreeCache.cxx:70
 TTreeCache.cxx:71
 TTreeCache.cxx:72
 TTreeCache.cxx:73
 TTreeCache.cxx:74
 TTreeCache.cxx:75
 TTreeCache.cxx:76
 TTreeCache.cxx:77
 TTreeCache.cxx:78
 TTreeCache.cxx:79
 TTreeCache.cxx:80
 TTreeCache.cxx:81
 TTreeCache.cxx:82
 TTreeCache.cxx:83
 TTreeCache.cxx:84
 TTreeCache.cxx:85
 TTreeCache.cxx:86
 TTreeCache.cxx:87
 TTreeCache.cxx:88
 TTreeCache.cxx:89
 TTreeCache.cxx:90
 TTreeCache.cxx:91
 TTreeCache.cxx:92
 TTreeCache.cxx:93
 TTreeCache.cxx:94
 TTreeCache.cxx:95
 TTreeCache.cxx:96
 TTreeCache.cxx:97
 TTreeCache.cxx:98
 TTreeCache.cxx:99
 TTreeCache.cxx:100
 TTreeCache.cxx:101
 TTreeCache.cxx:102
 TTreeCache.cxx:103
 TTreeCache.cxx:104
 TTreeCache.cxx:105
 TTreeCache.cxx:106
 TTreeCache.cxx:107
 TTreeCache.cxx:108
 TTreeCache.cxx:109
 TTreeCache.cxx:110
 TTreeCache.cxx:111
 TTreeCache.cxx:112
 TTreeCache.cxx:113
 TTreeCache.cxx:114
 TTreeCache.cxx:115
 TTreeCache.cxx:116
 TTreeCache.cxx:117
 TTreeCache.cxx:118
 TTreeCache.cxx:119
 TTreeCache.cxx:120
 TTreeCache.cxx:121
 TTreeCache.cxx:122
 TTreeCache.cxx:123
 TTreeCache.cxx:124
 TTreeCache.cxx:125
 TTreeCache.cxx:126
 TTreeCache.cxx:127
 TTreeCache.cxx:128
 TTreeCache.cxx:129
 TTreeCache.cxx:130
 TTreeCache.cxx:131
 TTreeCache.cxx:132
 TTreeCache.cxx:133
 TTreeCache.cxx:134
 TTreeCache.cxx:135
 TTreeCache.cxx:136
 TTreeCache.cxx:137
 TTreeCache.cxx:138
 TTreeCache.cxx:139
 TTreeCache.cxx:140
 TTreeCache.cxx:141
 TTreeCache.cxx:142
 TTreeCache.cxx:143
 TTreeCache.cxx:144
 TTreeCache.cxx:145
 TTreeCache.cxx:146
 TTreeCache.cxx:147
 TTreeCache.cxx:148
 TTreeCache.cxx:149
 TTreeCache.cxx:150
 TTreeCache.cxx:151
 TTreeCache.cxx:152
 TTreeCache.cxx:153
 TTreeCache.cxx:154
 TTreeCache.cxx:155
 TTreeCache.cxx:156
 TTreeCache.cxx:157
 TTreeCache.cxx:158
 TTreeCache.cxx:159
 TTreeCache.cxx:160
 TTreeCache.cxx:161
 TTreeCache.cxx:162
 TTreeCache.cxx:163
 TTreeCache.cxx:164
 TTreeCache.cxx:165
 TTreeCache.cxx:166
 TTreeCache.cxx:167
 TTreeCache.cxx:168
 TTreeCache.cxx:169
 TTreeCache.cxx:170
 TTreeCache.cxx:171
 TTreeCache.cxx:172
 TTreeCache.cxx:173
 TTreeCache.cxx:174
 TTreeCache.cxx:175
 TTreeCache.cxx:176
 TTreeCache.cxx:177
 TTreeCache.cxx:178
 TTreeCache.cxx:179
 TTreeCache.cxx:180
 TTreeCache.cxx:181
 TTreeCache.cxx:182
 TTreeCache.cxx:183
 TTreeCache.cxx:184
 TTreeCache.cxx:185
 TTreeCache.cxx:186
 TTreeCache.cxx:187
 TTreeCache.cxx:188
 TTreeCache.cxx:189
 TTreeCache.cxx:190
 TTreeCache.cxx:191
 TTreeCache.cxx:192
 TTreeCache.cxx:193
 TTreeCache.cxx:194
 TTreeCache.cxx:195
 TTreeCache.cxx:196
 TTreeCache.cxx:197
 TTreeCache.cxx:198
 TTreeCache.cxx:199
 TTreeCache.cxx:200
 TTreeCache.cxx:201
 TTreeCache.cxx:202
 TTreeCache.cxx:203
 TTreeCache.cxx:204
 TTreeCache.cxx:205
 TTreeCache.cxx:206
 TTreeCache.cxx:207
 TTreeCache.cxx:208
 TTreeCache.cxx:209
 TTreeCache.cxx:210
 TTreeCache.cxx:211
 TTreeCache.cxx:212
 TTreeCache.cxx:213
 TTreeCache.cxx:214
 TTreeCache.cxx:215
 TTreeCache.cxx:216
 TTreeCache.cxx:217
 TTreeCache.cxx:218
 TTreeCache.cxx:219
 TTreeCache.cxx:220
 TTreeCache.cxx:221
 TTreeCache.cxx:222
 TTreeCache.cxx:223
 TTreeCache.cxx:224
 TTreeCache.cxx:225
 TTreeCache.cxx:226
 TTreeCache.cxx:227
 TTreeCache.cxx:228
 TTreeCache.cxx:229
 TTreeCache.cxx:230
 TTreeCache.cxx:231
 TTreeCache.cxx:232
 TTreeCache.cxx:233
 TTreeCache.cxx:234
 TTreeCache.cxx:235
 TTreeCache.cxx:236
 TTreeCache.cxx:237
 TTreeCache.cxx:238
 TTreeCache.cxx:239
 TTreeCache.cxx:240
 TTreeCache.cxx:241
 TTreeCache.cxx:242
 TTreeCache.cxx:243
 TTreeCache.cxx:244
 TTreeCache.cxx:245
 TTreeCache.cxx:246
 TTreeCache.cxx:247
 TTreeCache.cxx:248
 TTreeCache.cxx:249
 TTreeCache.cxx:250
 TTreeCache.cxx:251
 TTreeCache.cxx:252
 TTreeCache.cxx:253
 TTreeCache.cxx:254
 TTreeCache.cxx:255
 TTreeCache.cxx:256
 TTreeCache.cxx:257
 TTreeCache.cxx:258
 TTreeCache.cxx:259
 TTreeCache.cxx:260
 TTreeCache.cxx:261
 TTreeCache.cxx:262
 TTreeCache.cxx:263
 TTreeCache.cxx:264
 TTreeCache.cxx:265
 TTreeCache.cxx:266
 TTreeCache.cxx:267
 TTreeCache.cxx:268
 TTreeCache.cxx:269
 TTreeCache.cxx:270
 TTreeCache.cxx:271
 TTreeCache.cxx:272
 TTreeCache.cxx:273
 TTreeCache.cxx:274
 TTreeCache.cxx:275
 TTreeCache.cxx:276
 TTreeCache.cxx:277
 TTreeCache.cxx:278
 TTreeCache.cxx:279
 TTreeCache.cxx:280
 TTreeCache.cxx:281
 TTreeCache.cxx:282
 TTreeCache.cxx:283
 TTreeCache.cxx:284
 TTreeCache.cxx:285
 TTreeCache.cxx:286
 TTreeCache.cxx:287
 TTreeCache.cxx:288
 TTreeCache.cxx:289
 TTreeCache.cxx:290
 TTreeCache.cxx:291
 TTreeCache.cxx:292
 TTreeCache.cxx:293
 TTreeCache.cxx:294
 TTreeCache.cxx:295
 TTreeCache.cxx:296
 TTreeCache.cxx:297
 TTreeCache.cxx:298
 TTreeCache.cxx:299
 TTreeCache.cxx:300
 TTreeCache.cxx:301
 TTreeCache.cxx:302
 TTreeCache.cxx:303
 TTreeCache.cxx:304
 TTreeCache.cxx:305
 TTreeCache.cxx:306
 TTreeCache.cxx:307
 TTreeCache.cxx:308
 TTreeCache.cxx:309
 TTreeCache.cxx:310
 TTreeCache.cxx:311
 TTreeCache.cxx:312
 TTreeCache.cxx:313
 TTreeCache.cxx:314
 TTreeCache.cxx:315
 TTreeCache.cxx:316
 TTreeCache.cxx:317
 TTreeCache.cxx:318
 TTreeCache.cxx:319
 TTreeCache.cxx:320
 TTreeCache.cxx:321
 TTreeCache.cxx:322
 TTreeCache.cxx:323
 TTreeCache.cxx:324
 TTreeCache.cxx:325
 TTreeCache.cxx:326
 TTreeCache.cxx:327
 TTreeCache.cxx:328
 TTreeCache.cxx:329
 TTreeCache.cxx:330
 TTreeCache.cxx:331
 TTreeCache.cxx:332
 TTreeCache.cxx:333
 TTreeCache.cxx:334
 TTreeCache.cxx:335
 TTreeCache.cxx:336
 TTreeCache.cxx:337
 TTreeCache.cxx:338
 TTreeCache.cxx:339
 TTreeCache.cxx:340
 TTreeCache.cxx:341
 TTreeCache.cxx:342
 TTreeCache.cxx:343
 TTreeCache.cxx:344
 TTreeCache.cxx:345
 TTreeCache.cxx:346
 TTreeCache.cxx:347
 TTreeCache.cxx:348
 TTreeCache.cxx:349
 TTreeCache.cxx:350
 TTreeCache.cxx:351
 TTreeCache.cxx:352
 TTreeCache.cxx:353
 TTreeCache.cxx:354
 TTreeCache.cxx:355
 TTreeCache.cxx:356
 TTreeCache.cxx:357
 TTreeCache.cxx:358
 TTreeCache.cxx:359
 TTreeCache.cxx:360
 TTreeCache.cxx:361
 TTreeCache.cxx:362
 TTreeCache.cxx:363
 TTreeCache.cxx:364
 TTreeCache.cxx:365
 TTreeCache.cxx:366
 TTreeCache.cxx:367
 TTreeCache.cxx:368
 TTreeCache.cxx:369
 TTreeCache.cxx:370
 TTreeCache.cxx:371
 TTreeCache.cxx:372
 TTreeCache.cxx:373
 TTreeCache.cxx:374
 TTreeCache.cxx:375
 TTreeCache.cxx:376
 TTreeCache.cxx:377
 TTreeCache.cxx:378
 TTreeCache.cxx:379
 TTreeCache.cxx:380
 TTreeCache.cxx:381
 TTreeCache.cxx:382
 TTreeCache.cxx:383
 TTreeCache.cxx:384
 TTreeCache.cxx:385
 TTreeCache.cxx:386
 TTreeCache.cxx:387
 TTreeCache.cxx:388
 TTreeCache.cxx:389
 TTreeCache.cxx:390
 TTreeCache.cxx:391
 TTreeCache.cxx:392
 TTreeCache.cxx:393
 TTreeCache.cxx:394
 TTreeCache.cxx:395
 TTreeCache.cxx:396
 TTreeCache.cxx:397
 TTreeCache.cxx:398
 TTreeCache.cxx:399
 TTreeCache.cxx:400
 TTreeCache.cxx:401
 TTreeCache.cxx:402
 TTreeCache.cxx:403
 TTreeCache.cxx:404
 TTreeCache.cxx:405
 TTreeCache.cxx:406
 TTreeCache.cxx:407
 TTreeCache.cxx:408
 TTreeCache.cxx:409
 TTreeCache.cxx:410
 TTreeCache.cxx:411
 TTreeCache.cxx:412
 TTreeCache.cxx:413
 TTreeCache.cxx:414
 TTreeCache.cxx:415
 TTreeCache.cxx:416
 TTreeCache.cxx:417
 TTreeCache.cxx:418
 TTreeCache.cxx:419
 TTreeCache.cxx:420
 TTreeCache.cxx:421
 TTreeCache.cxx:422
 TTreeCache.cxx:423
 TTreeCache.cxx:424
 TTreeCache.cxx:425
 TTreeCache.cxx:426
 TTreeCache.cxx:427
 TTreeCache.cxx:428
 TTreeCache.cxx:429
 TTreeCache.cxx:430
 TTreeCache.cxx:431
 TTreeCache.cxx:432
 TTreeCache.cxx:433
 TTreeCache.cxx:434
 TTreeCache.cxx:435
 TTreeCache.cxx:436
 TTreeCache.cxx:437
 TTreeCache.cxx:438
 TTreeCache.cxx:439
 TTreeCache.cxx:440
 TTreeCache.cxx:441
 TTreeCache.cxx:442
 TTreeCache.cxx:443
 TTreeCache.cxx:444
 TTreeCache.cxx:445
 TTreeCache.cxx:446
 TTreeCache.cxx:447
 TTreeCache.cxx:448
 TTreeCache.cxx:449
 TTreeCache.cxx:450
 TTreeCache.cxx:451
 TTreeCache.cxx:452
 TTreeCache.cxx:453
 TTreeCache.cxx:454
 TTreeCache.cxx:455
 TTreeCache.cxx:456
 TTreeCache.cxx:457
 TTreeCache.cxx:458
 TTreeCache.cxx:459
 TTreeCache.cxx:460
 TTreeCache.cxx:461
 TTreeCache.cxx:462
 TTreeCache.cxx:463
 TTreeCache.cxx:464
 TTreeCache.cxx:465
 TTreeCache.cxx:466
 TTreeCache.cxx:467
 TTreeCache.cxx:468
 TTreeCache.cxx:469
 TTreeCache.cxx:470
 TTreeCache.cxx:471
 TTreeCache.cxx:472
 TTreeCache.cxx:473
 TTreeCache.cxx:474
 TTreeCache.cxx:475
 TTreeCache.cxx:476
 TTreeCache.cxx:477
 TTreeCache.cxx:478
 TTreeCache.cxx:479
 TTreeCache.cxx:480
 TTreeCache.cxx:481
 TTreeCache.cxx:482
 TTreeCache.cxx:483
 TTreeCache.cxx:484
 TTreeCache.cxx:485
 TTreeCache.cxx:486
 TTreeCache.cxx:487
 TTreeCache.cxx:488
 TTreeCache.cxx:489
 TTreeCache.cxx:490
 TTreeCache.cxx:491
 TTreeCache.cxx:492
 TTreeCache.cxx:493
 TTreeCache.cxx:494
 TTreeCache.cxx:495
 TTreeCache.cxx:496
 TTreeCache.cxx:497
 TTreeCache.cxx:498
 TTreeCache.cxx:499
 TTreeCache.cxx:500
 TTreeCache.cxx:501
 TTreeCache.cxx:502
 TTreeCache.cxx:503
 TTreeCache.cxx:504
 TTreeCache.cxx:505
 TTreeCache.cxx:506
 TTreeCache.cxx:507
 TTreeCache.cxx:508
 TTreeCache.cxx:509
 TTreeCache.cxx:510
 TTreeCache.cxx:511
 TTreeCache.cxx:512
 TTreeCache.cxx:513
 TTreeCache.cxx:514
 TTreeCache.cxx:515
 TTreeCache.cxx:516
 TTreeCache.cxx:517
 TTreeCache.cxx:518
 TTreeCache.cxx:519
 TTreeCache.cxx:520
 TTreeCache.cxx:521
 TTreeCache.cxx:522
 TTreeCache.cxx:523
 TTreeCache.cxx:524
 TTreeCache.cxx:525
 TTreeCache.cxx:526
 TTreeCache.cxx:527
 TTreeCache.cxx:528
 TTreeCache.cxx:529
 TTreeCache.cxx:530
 TTreeCache.cxx:531
 TTreeCache.cxx:532
 TTreeCache.cxx:533
 TTreeCache.cxx:534
 TTreeCache.cxx:535
 TTreeCache.cxx:536
 TTreeCache.cxx:537
 TTreeCache.cxx:538
 TTreeCache.cxx:539
 TTreeCache.cxx:540
 TTreeCache.cxx:541
 TTreeCache.cxx:542
 TTreeCache.cxx:543
 TTreeCache.cxx:544
 TTreeCache.cxx:545
 TTreeCache.cxx:546
 TTreeCache.cxx:547
 TTreeCache.cxx:548
 TTreeCache.cxx:549
 TTreeCache.cxx:550
 TTreeCache.cxx:551
 TTreeCache.cxx:552
 TTreeCache.cxx:553
 TTreeCache.cxx:554
 TTreeCache.cxx:555
 TTreeCache.cxx:556
 TTreeCache.cxx:557
 TTreeCache.cxx:558
 TTreeCache.cxx:559
 TTreeCache.cxx:560
 TTreeCache.cxx:561
 TTreeCache.cxx:562
 TTreeCache.cxx:563
 TTreeCache.cxx:564
 TTreeCache.cxx:565
 TTreeCache.cxx:566
 TTreeCache.cxx:567
 TTreeCache.cxx:568
 TTreeCache.cxx:569
 TTreeCache.cxx:570
 TTreeCache.cxx:571
 TTreeCache.cxx:572
 TTreeCache.cxx:573
 TTreeCache.cxx:574
 TTreeCache.cxx:575
 TTreeCache.cxx:576
 TTreeCache.cxx:577
 TTreeCache.cxx:578
 TTreeCache.cxx:579
 TTreeCache.cxx:580
 TTreeCache.cxx:581
 TTreeCache.cxx:582
 TTreeCache.cxx:583
 TTreeCache.cxx:584
 TTreeCache.cxx:585
 TTreeCache.cxx:586
 TTreeCache.cxx:587
 TTreeCache.cxx:588
 TTreeCache.cxx:589
 TTreeCache.cxx:590
 TTreeCache.cxx:591
 TTreeCache.cxx:592
 TTreeCache.cxx:593
 TTreeCache.cxx:594
 TTreeCache.cxx:595
 TTreeCache.cxx:596
 TTreeCache.cxx:597
 TTreeCache.cxx:598
 TTreeCache.cxx:599
 TTreeCache.cxx:600
 TTreeCache.cxx:601
 TTreeCache.cxx:602
 TTreeCache.cxx:603
 TTreeCache.cxx:604
 TTreeCache.cxx:605
 TTreeCache.cxx:606
 TTreeCache.cxx:607
 TTreeCache.cxx:608
 TTreeCache.cxx:609
 TTreeCache.cxx:610
 TTreeCache.cxx:611
 TTreeCache.cxx:612
 TTreeCache.cxx:613
 TTreeCache.cxx:614
 TTreeCache.cxx:615
 TTreeCache.cxx:616
 TTreeCache.cxx:617
 TTreeCache.cxx:618
 TTreeCache.cxx:619
 TTreeCache.cxx:620
 TTreeCache.cxx:621
 TTreeCache.cxx:622
 TTreeCache.cxx:623
 TTreeCache.cxx:624
 TTreeCache.cxx:625
 TTreeCache.cxx:626
 TTreeCache.cxx:627
 TTreeCache.cxx:628
 TTreeCache.cxx:629
 TTreeCache.cxx:630
 TTreeCache.cxx:631
 TTreeCache.cxx:632
 TTreeCache.cxx:633
 TTreeCache.cxx:634
 TTreeCache.cxx:635
 TTreeCache.cxx:636
 TTreeCache.cxx:637
 TTreeCache.cxx:638
 TTreeCache.cxx:639
 TTreeCache.cxx:640
 TTreeCache.cxx:641
 TTreeCache.cxx:642
 TTreeCache.cxx:643
 TTreeCache.cxx:644
 TTreeCache.cxx:645
 TTreeCache.cxx:646
 TTreeCache.cxx:647
 TTreeCache.cxx:648
 TTreeCache.cxx:649
 TTreeCache.cxx:650
 TTreeCache.cxx:651
 TTreeCache.cxx:652
 TTreeCache.cxx:653
 TTreeCache.cxx:654
 TTreeCache.cxx:655
 TTreeCache.cxx:656
 TTreeCache.cxx:657
 TTreeCache.cxx:658
 TTreeCache.cxx:659
 TTreeCache.cxx:660
 TTreeCache.cxx:661
 TTreeCache.cxx:662
 TTreeCache.cxx:663
 TTreeCache.cxx:664
 TTreeCache.cxx:665
 TTreeCache.cxx:666
 TTreeCache.cxx:667
 TTreeCache.cxx:668
 TTreeCache.cxx:669
 TTreeCache.cxx:670
 TTreeCache.cxx:671
 TTreeCache.cxx:672
 TTreeCache.cxx:673
 TTreeCache.cxx:674
 TTreeCache.cxx:675
 TTreeCache.cxx:676
 TTreeCache.cxx:677
 TTreeCache.cxx:678
 TTreeCache.cxx:679
 TTreeCache.cxx:680
 TTreeCache.cxx:681
 TTreeCache.cxx:682
 TTreeCache.cxx:683
 TTreeCache.cxx:684
 TTreeCache.cxx:685
 TTreeCache.cxx:686
 TTreeCache.cxx:687
 TTreeCache.cxx:688
 TTreeCache.cxx:689
 TTreeCache.cxx:690
 TTreeCache.cxx:691
 TTreeCache.cxx:692
 TTreeCache.cxx:693
 TTreeCache.cxx:694
 TTreeCache.cxx:695
 TTreeCache.cxx:696
 TTreeCache.cxx:697
 TTreeCache.cxx:698
 TTreeCache.cxx:699
 TTreeCache.cxx:700
 TTreeCache.cxx:701
 TTreeCache.cxx:702
 TTreeCache.cxx:703
 TTreeCache.cxx:704
 TTreeCache.cxx:705
 TTreeCache.cxx:706
 TTreeCache.cxx:707
 TTreeCache.cxx:708
 TTreeCache.cxx:709
 TTreeCache.cxx:710
 TTreeCache.cxx:711
 TTreeCache.cxx:712
 TTreeCache.cxx:713
 TTreeCache.cxx:714
 TTreeCache.cxx:715
 TTreeCache.cxx:716
 TTreeCache.cxx:717
 TTreeCache.cxx:718
 TTreeCache.cxx:719
 TTreeCache.cxx:720
 TTreeCache.cxx:721
 TTreeCache.cxx:722
 TTreeCache.cxx:723
 TTreeCache.cxx:724
 TTreeCache.cxx:725
 TTreeCache.cxx:726
 TTreeCache.cxx:727
 TTreeCache.cxx:728
 TTreeCache.cxx:729
 TTreeCache.cxx:730
 TTreeCache.cxx:731
 TTreeCache.cxx:732
 TTreeCache.cxx:733
 TTreeCache.cxx:734
 TTreeCache.cxx:735
 TTreeCache.cxx:736
 TTreeCache.cxx:737
 TTreeCache.cxx:738
 TTreeCache.cxx:739
 TTreeCache.cxx:740
 TTreeCache.cxx:741
 TTreeCache.cxx:742
 TTreeCache.cxx:743
 TTreeCache.cxx:744
 TTreeCache.cxx:745
 TTreeCache.cxx:746
 TTreeCache.cxx:747
 TTreeCache.cxx:748
 TTreeCache.cxx:749
 TTreeCache.cxx:750
 TTreeCache.cxx:751
 TTreeCache.cxx:752
 TTreeCache.cxx:753
 TTreeCache.cxx:754
 TTreeCache.cxx:755
 TTreeCache.cxx:756
 TTreeCache.cxx:757
 TTreeCache.cxx:758
 TTreeCache.cxx:759
 TTreeCache.cxx:760
 TTreeCache.cxx:761
 TTreeCache.cxx:762
 TTreeCache.cxx:763
 TTreeCache.cxx:764
 TTreeCache.cxx:765
 TTreeCache.cxx:766
 TTreeCache.cxx:767
 TTreeCache.cxx:768
 TTreeCache.cxx:769
 TTreeCache.cxx:770
 TTreeCache.cxx:771
 TTreeCache.cxx:772
 TTreeCache.cxx:773
 TTreeCache.cxx:774
 TTreeCache.cxx:775
 TTreeCache.cxx:776
 TTreeCache.cxx:777
 TTreeCache.cxx:778
 TTreeCache.cxx:779
 TTreeCache.cxx:780
 TTreeCache.cxx:781
 TTreeCache.cxx:782
 TTreeCache.cxx:783
 TTreeCache.cxx:784
 TTreeCache.cxx:785
 TTreeCache.cxx:786
 TTreeCache.cxx:787
 TTreeCache.cxx:788
 TTreeCache.cxx:789
 TTreeCache.cxx:790
 TTreeCache.cxx:791
 TTreeCache.cxx:792
 TTreeCache.cxx:793
 TTreeCache.cxx:794
 TTreeCache.cxx:795
 TTreeCache.cxx:796
 TTreeCache.cxx:797
 TTreeCache.cxx:798
 TTreeCache.cxx:799
 TTreeCache.cxx:800
 TTreeCache.cxx:801
 TTreeCache.cxx:802
 TTreeCache.cxx:803
 TTreeCache.cxx:804
 TTreeCache.cxx:805
 TTreeCache.cxx:806
 TTreeCache.cxx:807
 TTreeCache.cxx:808
 TTreeCache.cxx:809
 TTreeCache.cxx:810
 TTreeCache.cxx:811
 TTreeCache.cxx:812
 TTreeCache.cxx:813
 TTreeCache.cxx:814
 TTreeCache.cxx:815
 TTreeCache.cxx:816
 TTreeCache.cxx:817
 TTreeCache.cxx:818
 TTreeCache.cxx:819
 TTreeCache.cxx:820
 TTreeCache.cxx:821
 TTreeCache.cxx:822
 TTreeCache.cxx:823
 TTreeCache.cxx:824
 TTreeCache.cxx:825
 TTreeCache.cxx:826
 TTreeCache.cxx:827
 TTreeCache.cxx:828
 TTreeCache.cxx:829
 TTreeCache.cxx:830
 TTreeCache.cxx:831
 TTreeCache.cxx:832
 TTreeCache.cxx:833
 TTreeCache.cxx:834
 TTreeCache.cxx:835
 TTreeCache.cxx:836
 TTreeCache.cxx:837
 TTreeCache.cxx:838
 TTreeCache.cxx:839
 TTreeCache.cxx:840
 TTreeCache.cxx:841
 TTreeCache.cxx:842
 TTreeCache.cxx:843
 TTreeCache.cxx:844
 TTreeCache.cxx:845
 TTreeCache.cxx:846
 TTreeCache.cxx:847
 TTreeCache.cxx:848
 TTreeCache.cxx:849
 TTreeCache.cxx:850
 TTreeCache.cxx:851
 TTreeCache.cxx:852
 TTreeCache.cxx:853
 TTreeCache.cxx:854
 TTreeCache.cxx:855
 TTreeCache.cxx:856
 TTreeCache.cxx:857
 TTreeCache.cxx:858
 TTreeCache.cxx:859
 TTreeCache.cxx:860
 TTreeCache.cxx:861
 TTreeCache.cxx:862
 TTreeCache.cxx:863
 TTreeCache.cxx:864
 TTreeCache.cxx:865
 TTreeCache.cxx:866
 TTreeCache.cxx:867
 TTreeCache.cxx:868
 TTreeCache.cxx:869
 TTreeCache.cxx:870
 TTreeCache.cxx:871
 TTreeCache.cxx:872
 TTreeCache.cxx:873
 TTreeCache.cxx:874
 TTreeCache.cxx:875
 TTreeCache.cxx:876
 TTreeCache.cxx:877
 TTreeCache.cxx:878
 TTreeCache.cxx:879
 TTreeCache.cxx:880
 TTreeCache.cxx:881
 TTreeCache.cxx:882
 TTreeCache.cxx:883
 TTreeCache.cxx:884
 TTreeCache.cxx:885
 TTreeCache.cxx:886
 TTreeCache.cxx:887
 TTreeCache.cxx:888
 TTreeCache.cxx:889
 TTreeCache.cxx:890
 TTreeCache.cxx:891
 TTreeCache.cxx:892
 TTreeCache.cxx:893
 TTreeCache.cxx:894
 TTreeCache.cxx:895
 TTreeCache.cxx:896
 TTreeCache.cxx:897
 TTreeCache.cxx:898
 TTreeCache.cxx:899
 TTreeCache.cxx:900
 TTreeCache.cxx:901
 TTreeCache.cxx:902
 TTreeCache.cxx:903
 TTreeCache.cxx:904
 TTreeCache.cxx:905
 TTreeCache.cxx:906
 TTreeCache.cxx:907
 TTreeCache.cxx:908
 TTreeCache.cxx:909
 TTreeCache.cxx:910
 TTreeCache.cxx:911
 TTreeCache.cxx:912
 TTreeCache.cxx:913
 TTreeCache.cxx:914
 TTreeCache.cxx:915
 TTreeCache.cxx:916
 TTreeCache.cxx:917
 TTreeCache.cxx:918
 TTreeCache.cxx:919
 TTreeCache.cxx:920
 TTreeCache.cxx:921
 TTreeCache.cxx:922
 TTreeCache.cxx:923
 TTreeCache.cxx:924
 TTreeCache.cxx:925
 TTreeCache.cxx:926
 TTreeCache.cxx:927
 TTreeCache.cxx:928
 TTreeCache.cxx:929
 TTreeCache.cxx:930
 TTreeCache.cxx:931
 TTreeCache.cxx:932
 TTreeCache.cxx:933
 TTreeCache.cxx:934
 TTreeCache.cxx:935
 TTreeCache.cxx:936
 TTreeCache.cxx:937
 TTreeCache.cxx:938
 TTreeCache.cxx:939
 TTreeCache.cxx:940
 TTreeCache.cxx:941
 TTreeCache.cxx:942
 TTreeCache.cxx:943
 TTreeCache.cxx:944
 TTreeCache.cxx:945
 TTreeCache.cxx:946
 TTreeCache.cxx:947
 TTreeCache.cxx:948
 TTreeCache.cxx:949
 TTreeCache.cxx:950
 TTreeCache.cxx:951
 TTreeCache.cxx:952
 TTreeCache.cxx:953
 TTreeCache.cxx:954
 TTreeCache.cxx:955
 TTreeCache.cxx:956
 TTreeCache.cxx:957
 TTreeCache.cxx:958
 TTreeCache.cxx:959
 TTreeCache.cxx:960
 TTreeCache.cxx:961
 TTreeCache.cxx:962
 TTreeCache.cxx:963
 TTreeCache.cxx:964
 TTreeCache.cxx:965
 TTreeCache.cxx:966
 TTreeCache.cxx:967
 TTreeCache.cxx:968
 TTreeCache.cxx:969
 TTreeCache.cxx:970
 TTreeCache.cxx:971
 TTreeCache.cxx:972
 TTreeCache.cxx:973
 TTreeCache.cxx:974
 TTreeCache.cxx:975
 TTreeCache.cxx:976
 TTreeCache.cxx:977
 TTreeCache.cxx:978
 TTreeCache.cxx:979
 TTreeCache.cxx:980
 TTreeCache.cxx:981
 TTreeCache.cxx:982
 TTreeCache.cxx:983
 TTreeCache.cxx:984
 TTreeCache.cxx:985
 TTreeCache.cxx:986
 TTreeCache.cxx:987
 TTreeCache.cxx:988
 TTreeCache.cxx:989
 TTreeCache.cxx:990
 TTreeCache.cxx:991
 TTreeCache.cxx:992
 TTreeCache.cxx:993
 TTreeCache.cxx:994
 TTreeCache.cxx:995
 TTreeCache.cxx:996
 TTreeCache.cxx:997
 TTreeCache.cxx:998
 TTreeCache.cxx:999
 TTreeCache.cxx:1000
 TTreeCache.cxx:1001
 TTreeCache.cxx:1002
 TTreeCache.cxx:1003
 TTreeCache.cxx:1004
 TTreeCache.cxx:1005
 TTreeCache.cxx:1006
 TTreeCache.cxx:1007
 TTreeCache.cxx:1008
 TTreeCache.cxx:1009
 TTreeCache.cxx:1010
 TTreeCache.cxx:1011
 TTreeCache.cxx:1012
 TTreeCache.cxx:1013
 TTreeCache.cxx:1014
 TTreeCache.cxx:1015
 TTreeCache.cxx:1016
 TTreeCache.cxx:1017
 TTreeCache.cxx:1018
 TTreeCache.cxx:1019
 TTreeCache.cxx:1020
 TTreeCache.cxx:1021
 TTreeCache.cxx:1022
 TTreeCache.cxx:1023
 TTreeCache.cxx:1024
 TTreeCache.cxx:1025
 TTreeCache.cxx:1026
 TTreeCache.cxx:1027
 TTreeCache.cxx:1028
 TTreeCache.cxx:1029
 TTreeCache.cxx:1030
 TTreeCache.cxx:1031
 TTreeCache.cxx:1032
 TTreeCache.cxx:1033
 TTreeCache.cxx:1034
 TTreeCache.cxx:1035
 TTreeCache.cxx:1036
 TTreeCache.cxx:1037
 TTreeCache.cxx:1038
 TTreeCache.cxx:1039
 TTreeCache.cxx:1040
 TTreeCache.cxx:1041
 TTreeCache.cxx:1042
 TTreeCache.cxx:1043
 TTreeCache.cxx:1044
 TTreeCache.cxx:1045
 TTreeCache.cxx:1046
 TTreeCache.cxx:1047
 TTreeCache.cxx:1048
 TTreeCache.cxx:1049
 TTreeCache.cxx:1050
 TTreeCache.cxx:1051
 TTreeCache.cxx:1052
 TTreeCache.cxx:1053
 TTreeCache.cxx:1054
 TTreeCache.cxx:1055
 TTreeCache.cxx:1056
 TTreeCache.cxx:1057
 TTreeCache.cxx:1058
 TTreeCache.cxx:1059
 TTreeCache.cxx:1060
 TTreeCache.cxx:1061
 TTreeCache.cxx:1062
 TTreeCache.cxx:1063
 TTreeCache.cxx:1064
 TTreeCache.cxx:1065
 TTreeCache.cxx:1066
 TTreeCache.cxx:1067
 TTreeCache.cxx:1068
 TTreeCache.cxx:1069
 TTreeCache.cxx:1070
 TTreeCache.cxx:1071
 TTreeCache.cxx:1072
 TTreeCache.cxx:1073
 TTreeCache.cxx:1074
 TTreeCache.cxx:1075
 TTreeCache.cxx:1076
 TTreeCache.cxx:1077
 TTreeCache.cxx:1078
 TTreeCache.cxx:1079
 TTreeCache.cxx:1080
 TTreeCache.cxx:1081
 TTreeCache.cxx:1082
 TTreeCache.cxx:1083
 TTreeCache.cxx:1084
 TTreeCache.cxx:1085
 TTreeCache.cxx:1086
 TTreeCache.cxx:1087
 TTreeCache.cxx:1088
 TTreeCache.cxx:1089
 TTreeCache.cxx:1090
 TTreeCache.cxx:1091
 TTreeCache.cxx:1092
 TTreeCache.cxx:1093
 TTreeCache.cxx:1094
 TTreeCache.cxx:1095
 TTreeCache.cxx:1096
 TTreeCache.cxx:1097
 TTreeCache.cxx:1098
 TTreeCache.cxx:1099
 TTreeCache.cxx:1100
 TTreeCache.cxx:1101
 TTreeCache.cxx:1102
 TTreeCache.cxx:1103
 TTreeCache.cxx:1104
 TTreeCache.cxx:1105
 TTreeCache.cxx:1106
 TTreeCache.cxx:1107
 TTreeCache.cxx:1108
 TTreeCache.cxx:1109
 TTreeCache.cxx:1110
 TTreeCache.cxx:1111
 TTreeCache.cxx:1112
 TTreeCache.cxx:1113
 TTreeCache.cxx:1114
 TTreeCache.cxx:1115
 TTreeCache.cxx:1116
 TTreeCache.cxx:1117
 TTreeCache.cxx:1118
 TTreeCache.cxx:1119
 TTreeCache.cxx:1120
 TTreeCache.cxx:1121
 TTreeCache.cxx:1122
 TTreeCache.cxx:1123
 TTreeCache.cxx:1124
 TTreeCache.cxx:1125
 TTreeCache.cxx:1126
 TTreeCache.cxx:1127
 TTreeCache.cxx:1128
 TTreeCache.cxx:1129
 TTreeCache.cxx:1130
 TTreeCache.cxx:1131
 TTreeCache.cxx:1132
 TTreeCache.cxx:1133
 TTreeCache.cxx:1134
 TTreeCache.cxx:1135
 TTreeCache.cxx:1136
 TTreeCache.cxx:1137
 TTreeCache.cxx:1138
 TTreeCache.cxx:1139
 TTreeCache.cxx:1140
 TTreeCache.cxx:1141
 TTreeCache.cxx:1142
 TTreeCache.cxx:1143
 TTreeCache.cxx:1144
 TTreeCache.cxx:1145
 TTreeCache.cxx:1146
 TTreeCache.cxx:1147
 TTreeCache.cxx:1148
 TTreeCache.cxx:1149
 TTreeCache.cxx:1150
 TTreeCache.cxx:1151
 TTreeCache.cxx:1152
 TTreeCache.cxx:1153
 TTreeCache.cxx:1154
 TTreeCache.cxx:1155
 TTreeCache.cxx:1156
 TTreeCache.cxx:1157
 TTreeCache.cxx:1158
 TTreeCache.cxx:1159
 TTreeCache.cxx:1160
 TTreeCache.cxx:1161
 TTreeCache.cxx:1162
 TTreeCache.cxx:1163
 TTreeCache.cxx:1164
 TTreeCache.cxx:1165
 TTreeCache.cxx:1166
 TTreeCache.cxx:1167
 TTreeCache.cxx:1168
 TTreeCache.cxx:1169
 TTreeCache.cxx:1170
 TTreeCache.cxx:1171
 TTreeCache.cxx:1172
 TTreeCache.cxx:1173
 TTreeCache.cxx:1174
 TTreeCache.cxx:1175
 TTreeCache.cxx:1176
 TTreeCache.cxx:1177
 TTreeCache.cxx:1178
 TTreeCache.cxx:1179
 TTreeCache.cxx:1180
 TTreeCache.cxx:1181
 TTreeCache.cxx:1182
 TTreeCache.cxx:1183
 TTreeCache.cxx:1184
 TTreeCache.cxx:1185
 TTreeCache.cxx:1186
 TTreeCache.cxx:1187
 TTreeCache.cxx:1188
 TTreeCache.cxx:1189
 TTreeCache.cxx:1190
 TTreeCache.cxx:1191
 TTreeCache.cxx:1192
 TTreeCache.cxx:1193
 TTreeCache.cxx:1194
 TTreeCache.cxx:1195
 TTreeCache.cxx:1196
 TTreeCache.cxx:1197
 TTreeCache.cxx:1198
 TTreeCache.cxx:1199
 TTreeCache.cxx:1200
 TTreeCache.cxx:1201
 TTreeCache.cxx:1202
 TTreeCache.cxx:1203
 TTreeCache.cxx:1204
 TTreeCache.cxx:1205
 TTreeCache.cxx:1206
 TTreeCache.cxx:1207
 TTreeCache.cxx:1208
 TTreeCache.cxx:1209
 TTreeCache.cxx:1210
 TTreeCache.cxx:1211
 TTreeCache.cxx:1212
 TTreeCache.cxx:1213
 TTreeCache.cxx:1214
 TTreeCache.cxx:1215
 TTreeCache.cxx:1216
 TTreeCache.cxx:1217
 TTreeCache.cxx:1218
 TTreeCache.cxx:1219
 TTreeCache.cxx:1220
 TTreeCache.cxx:1221
 TTreeCache.cxx:1222
 TTreeCache.cxx:1223
 TTreeCache.cxx:1224
 TTreeCache.cxx:1225
 TTreeCache.cxx:1226
 TTreeCache.cxx:1227
 TTreeCache.cxx:1228
 TTreeCache.cxx:1229
 TTreeCache.cxx:1230
 TTreeCache.cxx:1231
 TTreeCache.cxx:1232
 TTreeCache.cxx:1233
 TTreeCache.cxx:1234
 TTreeCache.cxx:1235
 TTreeCache.cxx:1236
 TTreeCache.cxx:1237
 TTreeCache.cxx:1238
 TTreeCache.cxx:1239
 TTreeCache.cxx:1240
 TTreeCache.cxx:1241
 TTreeCache.cxx:1242
 TTreeCache.cxx:1243
 TTreeCache.cxx:1244
 TTreeCache.cxx:1245
 TTreeCache.cxx:1246
 TTreeCache.cxx:1247
 TTreeCache.cxx:1248
 TTreeCache.cxx:1249
 TTreeCache.cxx:1250
 TTreeCache.cxx:1251
 TTreeCache.cxx:1252
 TTreeCache.cxx:1253
 TTreeCache.cxx:1254
 TTreeCache.cxx:1255
 TTreeCache.cxx:1256
 TTreeCache.cxx:1257
 TTreeCache.cxx:1258
 TTreeCache.cxx:1259
 TTreeCache.cxx:1260
 TTreeCache.cxx:1261
 TTreeCache.cxx:1262
 TTreeCache.cxx:1263
 TTreeCache.cxx:1264
 TTreeCache.cxx:1265
 TTreeCache.cxx:1266
 TTreeCache.cxx:1267
 TTreeCache.cxx:1268
 TTreeCache.cxx:1269
 TTreeCache.cxx:1270
 TTreeCache.cxx:1271
 TTreeCache.cxx:1272
 TTreeCache.cxx:1273
 TTreeCache.cxx:1274
 TTreeCache.cxx:1275
 TTreeCache.cxx:1276
 TTreeCache.cxx:1277
 TTreeCache.cxx:1278
 TTreeCache.cxx:1279
 TTreeCache.cxx:1280
 TTreeCache.cxx:1281
 TTreeCache.cxx:1282
 TTreeCache.cxx:1283
 TTreeCache.cxx:1284
 TTreeCache.cxx:1285
 TTreeCache.cxx:1286
 TTreeCache.cxx:1287
 TTreeCache.cxx:1288
 TTreeCache.cxx:1289
 TTreeCache.cxx:1290
 TTreeCache.cxx:1291
 TTreeCache.cxx:1292
 TTreeCache.cxx:1293
 TTreeCache.cxx:1294
 TTreeCache.cxx:1295
 TTreeCache.cxx:1296
 TTreeCache.cxx:1297
 TTreeCache.cxx:1298
 TTreeCache.cxx:1299
 TTreeCache.cxx:1300
 TTreeCache.cxx:1301
 TTreeCache.cxx:1302
 TTreeCache.cxx:1303
 TTreeCache.cxx:1304
 TTreeCache.cxx:1305
 TTreeCache.cxx:1306
 TTreeCache.cxx:1307
 TTreeCache.cxx:1308
 TTreeCache.cxx:1309
 TTreeCache.cxx:1310
 TTreeCache.cxx:1311
 TTreeCache.cxx:1312
 TTreeCache.cxx:1313
 TTreeCache.cxx:1314
 TTreeCache.cxx:1315
 TTreeCache.cxx:1316
 TTreeCache.cxx:1317
 TTreeCache.cxx:1318
 TTreeCache.cxx:1319
 TTreeCache.cxx:1320
 TTreeCache.cxx:1321
 TTreeCache.cxx:1322
 TTreeCache.cxx:1323
 TTreeCache.cxx:1324
 TTreeCache.cxx:1325
 TTreeCache.cxx:1326
 TTreeCache.cxx:1327
 TTreeCache.cxx:1328
 TTreeCache.cxx:1329