// @(#)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.             *
 *************************************************************************/

//////////////////////////////////////////////////////////////////////////
//                                                                      //
// TTree                                                                //
//                                                                      //
//  A TTree object has a header with a name and a title.
//  It consists of a list of independent branches (TBranch). Each branch
//  has its own definition and list of buffers. Branch buffers may be
//  automatically written to disk or kept in memory until the Tree attribute
//  fMaxVirtualSize is reached. Variables of one branch are written to the
//  same buffer. A branch buffer is automatically compressed if the file
//  compression attribute is set (default).
//
//  Branches may be written to different files (see TBranch::SetFile).
//
//  The ROOT user can decide to make one single branch and serialize one
//  object into one single I/O buffer or to make several branches.
//  Making one single branch and one single buffer can be the right choice
//  when one wants to process only a subset of all entries in the tree.
//  (you know for example the list of entry numbers you want to process).
//  Making several branches is particularly interesting in the data analysis
//  phase, when one wants to histogram some attributes of an object (entry)
//  without reading all the attributes.
//
//  ==> TTree *tree = new TTree(name, title)
//     Creates a Tree with name and title.
//
//     Various kinds of branches can be added to a tree:
//       A - simple structures or list of variables. (may be for C or Fortran structures)
//       B - any object (inheriting from TObject). (we expect this option be the most frequent)
//       C - a ClonesArray. (a specialized object for collections of same class objects)
//
//  ==> Case A
//      ======
//     TBranch *branch = tree->Branch(branchname, address, leaflist, bufsize)
//       * address is the address of the first item of a structure
//       * 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)
//       * If the address points to a single numerical variable, the leaflist is optional:
//           int value;
//           tree->Branch(branchname, &value);
//       * If the address points to more than one numerical variable, we strongly recommend
//         that the variable be sorted in decreasing order of size.  Any other order will
//         result in a non-portable (even between CINT and compiled code on the platform)
//         TTree (i.e. you will not be able to read it back on a platform with a different
//         padding strategy).
//
//  ==> Case B
//      ======
//     TBranch *branch = tree->Branch(branchname, &p_object, bufsize, splitlevel)/
//     TBranch *branch = tree->Branch(branchname, className, &p_object, bufsize, splitlevel)
//       * p_object is a pointer to an object.
//       * If className is not specified, Branch uses the type of p_object to determine the
//           type of the object.
//       * If className is used to specify explicitly the object type, the className must
//           be of a type related to the one pointed to by the pointer.  It should be either
//           a parent or derived class.
//       * if splitlevel=0, the object is serialized in the branch buffer.
//       * if splitlevel=1, this branch will automatically be split
//           into subbranches, with one subbranch for each data member or object
//           of the object itself. In case the object member is a TClonesArray,
//           the mechanism described in case C is applied to this array.
//       * if splitlevel=2 ,this branch will automatically be split
//           into subbranches, with one subbranch for each data member or object
//           of the object itself. In case the object member is a TClonesArray,
//           it is processed as a TObject*, only one branch.
//
//       Note: The pointer whose address is passed to TTree::Branch must not
//             be destroyed (i.e. go out of scope) until the TTree is deleted or
//             TTree::ResetBranchAddress is called.
//
//       Note: The pointer p_object must be initialized before calling TTree::Branch
//          Do either:
//             MyDataClass* p_object = 0;
//             tree->Branch(branchname, &p_object);
//          Or
//             MyDataClass* p_object = new MyDataClass;
//             tree->Branch(branchname, &p_object);
//       Whether the pointer is set to zero or not, the ownership of the object
//       is not taken over by the TTree.  I.e. eventhough an object will be allocated
//       by TTree::Branch if the pointer p_object is zero, the object will <b>not</b>
//       be deleted when the TTree is deleted.
//
//  ==> Case C
//      ======
//     MyClass object;
//     TBranch *branch = tree->Branch(branchname, &object, bufsize, splitlevel)
//
//       Note: The 2nd parameter must be the address of a valid object.
//              The object must not be destroyed (i.e. be deleted) until the TTree
//               is deleted or TTree::ResetBranchAddress is called.
//
//       * if splitlevel=0, the object is serialized in the branch buffer.
//       * if splitlevel=1 (default), this branch will automatically be split
//           into subbranches, with one subbranch for each data member or object
//           of the object itself. In case the object member is a TClonesArray,
//           the mechanism described in case C is applied to this array.
//       * if splitlevel=2 ,this branch will automatically be split
//           into subbranches, with one subbranch for each data member or object
//           of the object itself. In case the object member is a TClonesArray,
//           it is processed as a TObject*, only one branch.
//
//  ==> Case D
//      ======
//     TBranch *branch = tree->Branch(branchname,clonesarray, bufsize, splitlevel)
//         clonesarray is the address of a pointer to a TClonesArray.
//         The TClonesArray is a direct access list of objects of the same class.
//         For example, if the TClonesArray is an array of TTrack objects,
//         this function will create one subbranch for each data member of
//         the object TTrack.
//
//  ==> Case E
//      ======
//     TBranch *branch = tree->Branch( branchname, STLcollection, buffsize, splitlevel);
//         STLcollection is the address of a pointer to std::vector, std::list,
//         std::deque, std::set or std::multiset containing pointers to objects.
//         If the splitlevel is a value bigger than 100 (TTree::kSplitCollectionOfPointers)
//         then the collection will be written in split mode, e.g. if it contains objects of
//         any types deriving from TTrack this function will sort the objects
//         based on their type and store them in separate branches in split
//         mode.
//
//  ==> branch->SetAddress(Void *address)
//      In case of dynamic structures changing with each entry for example, one must
//      redefine the branch address before filling the branch again.
//      This is done via the TBranch::SetAddress member function.
//
//  ==> tree->Fill()
//      loops on all defined branches and for each branch invokes the Fill function.
//
//         See also the class TNtuple (a simple Tree with branches of floats)
//         and the class TNtupleD (a simple Tree with branches of doubles)
//
//       Adding a Branch to an Existing Tree
//       ===================================
// You may want to add a branch to an existing tree. For example,
// if one variable in the tree was computed with a certain algorithm,
// you may want to try another algorithm and compare the results.
// One solution is to add a new branch, fill it, and save the tree.
// The code below adds a simple branch to an existing tree.
// Note the kOverwrite option in the Write method, it overwrites the
// existing tree. If it is not specified, two copies of the tree headers
// are saved.
//
// void tree3AddBranch(){
//   TFile f("tree3.root", "update");
//
//   Float_t new_v;
//   TTree *t3 = (TTree*)f->Get("t3");
//   TBranch *newBranch = t3->Branch("new_v", &new_v, "new_v/F");
//
//   //read the number of entries in the t3
//   Long64_t nentries = t3->GetEntries();
//
//   for (Long64_t i = 0; i < nentries; i++){
//     new_v= gRandom->Gaus(0, 1);
//     newBranch->Fill();
//   }
//   // save only the new version of the tree
//   t3->Write("", TObject::kOverwrite);
// }
// Adding a branch is often not possible because the tree is in a read-only
// file and you do not have permission to save the modified tree with the
// new branch. Even if you do have the permission, you risk losing the
// original tree with an unsuccessful attempt to save  the modification.
// Since trees are usually large, adding a branch could extend it over the
// 2GB limit. In this case, the attempt to write the tree fails, and the
// original data is erased.
// In addition, adding a branch to a tree enlarges the tree and increases
// the amount of memory needed to read an entry, and therefore decreases
// the performance.
//
// For these reasons, ROOT offers the concept of friends for trees (and chains).
// We encourage you to use TTree::AddFriend rather than adding a branch manually.
//
//Begin_Html
/*
<img src="gif/tree_layout.gif">
*/
//End_Html
//  =============================================================================
//______________________________________________________________________________
//*-*-*-*-*-*-*A simple example with histograms and a tree*-*-*-*-*-*-*-*-*-*
//*-*          ===========================================
//
//  This program creates :
//    - a one dimensional histogram
//    - a two dimensional histogram
//    - a profile histogram
//    - a tree
//
//  These objects are filled with some random numbers and saved on a file.
//
//-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*
//
// #include "TFile.h"
// #include "TH1.h"
// #include "TH2.h"
// #include "TProfile.h"
// #include "TRandom.h"
// #include "TTree.h"
//
//
// //______________________________________________________________________________
// main(int argc, char **argv)
// {
// // Create a new ROOT binary machine independent file.
// // Note that this file may contain any kind of ROOT objects, histograms,trees
// // pictures, graphics objects, detector geometries, tracks, events, etc..
// // This file is now becoming the current directory.
//   TFile hfile("htree.root","RECREATE","Demo ROOT file with histograms & trees");
//
// // Create some histograms and a profile histogram
//   TH1F *hpx   = new TH1F("hpx","This is the px distribution",100,-4,4);
//   TH2F *hpxpy = new TH2F("hpxpy","py ps px",40,-4,4,40,-4,4);
//   TProfile *hprof = new TProfile("hprof","Profile of pz versus px",100,-4,4,0,20);
//
// // Define some simple structures
//   typedef struct {Float_t x,y,z;} POINT;
//   typedef struct {
//      Int_t ntrack,nseg,nvertex;
//      UInt_t flag;
//      Float_t temperature;
//   } EVENTN;
//   static POINT point;
//   static EVENTN eventn;
//
// // Create a ROOT Tree
//   TTree *tree = new TTree("T","An example of ROOT tree with a few branches");
//   tree->Branch("point",&point,"x:y:z");
//   tree->Branch("eventn",&eventn,"ntrack/I:nseg:nvertex:flag/i:temperature/F");
//   tree->Branch("hpx","TH1F",&hpx,128000,0);
//
//   Float_t px,py,pz;
//   static Float_t p[3];
//
// //--------------------Here we start a loop on 1000 events
//   for ( Int_t i=0; i<1000; i++) {
//      gRandom->Rannor(px,py);
//      pz = px*px + py*py;
//      Float_t random = gRandom->::Rndm(1);
//
// //         Fill histograms
//      hpx->Fill(px);
//      hpxpy->Fill(px,py,1);
//      hprof->Fill(px,pz,1);
//
// //         Fill structures
//      p[0] = px;
//      p[1] = py;
//      p[2] = pz;
//      point.x = 10*(random-1);;
//      point.y = 5*random;
//      point.z = 20*random;
//      eventn.ntrack  = Int_t(100*random);
//      eventn.nseg    = Int_t(2*eventn.ntrack);
//      eventn.nvertex = 1;
//      eventn.flag    = Int_t(random+0.5);
//      eventn.temperature = 20+random;
//
// //        Fill the tree. For each event, save the 2 structures and 3 objects
// //      In this simple example, the objects hpx, hprof and hpxpy are slightly
// //      different from event to event. We expect a big compression factor!
//      tree->Fill();
//   }
//  //--------------End of the loop
//
//   tree->Print();
//
// // Save all objects in this file
//   hfile.Write();
//
// // Close the file. Note that this is automatically done when you leave
// // the application.
//   hfile.Close();
//
//   return 0;
// }
//                                                                      //
//////////////////////////////////////////////////////////////////////////

#include "RConfig.h"
#include "TTree.h"

#include "TArrayC.h"
#include "TBufferFile.h"
#include "TBaseClass.h"
#include "TBasket.h"
#include "TBranchClones.h"
#include "TBranchElement.h"
#include "TBranchObject.h"
#include "TBranchRef.h"
#include "TBrowser.h"
#include "TClass.h"
#include "TClassEdit.h"
#include "TClonesArray.h"
#include "TCut.h"
#include "TDataMember.h"
#include "TDataType.h"
#include "TDirectory.h"
#include "TError.h"
#include "TEntryList.h"
#include "TEnv.h"
#include "TEventList.h"
#include "TFile.h"
#include "TFolder.h"
#include "TFriendElement.h"
#include "TInterpreter.h"
#include "TLeaf.h"
#include "TLeafB.h"
#include "TLeafC.h"
#include "TLeafD.h"
#include "TLeafElement.h"
#include "TLeafF.h"
#include "TLeafI.h"
#include "TLeafL.h"
#include "TLeafObject.h"
#include "TLeafS.h"
#include "TList.h"
#include "TMath.h"
#include "TROOT.h"
#include "TRealData.h"
#include "TRegexp.h"
#include "TStreamerElement.h"
#include "TStreamerInfo.h"
#include "TStyle.h"
#include "TSystem.h"
#include "TTreeCloner.h"
#include "TTreeCache.h"
#include "TTreeCacheUnzip.h"
#include "TVirtualCollectionProxy.h"
#include "TEmulatedCollectionProxy.h"
#include "TVirtualFitter.h"
#include "TVirtualIndex.h"
#include "TVirtualPerfStats.h"
#include "TVirtualPad.h"
#include "TBranchSTL.h"
#include "TSchemaRuleSet.h"
#include "TFileMergeInfo.h"

#include <cstddef>
#include <fstream>
#include <sstream>
#include <string>
#include <stdio.h>
#include <limits.h>

Int_t    TTree::fgBranchStyle = 1;  // Use new TBranch style with TBranchElement.
Long64_t TTree::fgMaxTreeSize = 100000000000LL;

ClassImp(TTree)

//
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
//

static char DataTypeToChar(EDataType datatype)
{
   // Return the leaflist 'char' for a given datatype.

   switch(datatype) {
   case kChar_t:     return 'B';
   case kUChar_t:    return 'b';
   case kBool_t:     return 'O';
   case kShort_t:    return 'S';
   case kUShort_t:   return 's';
   case kCounter:
   case kInt_t:      return 'I';
   case kUInt_t:     return 'i';
   case kDouble_t:
   case kDouble32_t: return 'D';
   case kFloat_t:
   case kFloat16_t:  return 'F';
   case kLong_t:     return 0; // unsupported
   case kULong_t:    return 0; // unsupported?
   case kchar:       return 0; // unsupported
   case kLong64_t:   return 'L';
   case kULong64_t:  return 'l';

   case kCharStar:   return 'C';
   case kBits:       return 0; //unsupported

   case kOther_t:
   case kNoType_t:
   default:
      return 0;
   }
   return 0;
}

//______________________________________________________________________________
//  Helper class to prevent infinite recursion in the usage of TTree Friends.

//______________________________________________________________________________
TTree::TFriendLock::TFriendLock(TTree* tree, UInt_t methodbit)
: fTree(tree)
{
   // Record in tree that it has been used while recursively looks through the friends.

   // We could also add some code to acquire an actual
   // lock to prevent multi-thread issues
   fMethodBit = methodbit;
   if (fTree) {
      fPrevious = fTree->fFriendLockStatus & fMethodBit;
      fTree->fFriendLockStatus |= fMethodBit;
   } else {
      fPrevious = 0;
   }
}

//______________________________________________________________________________
TTree::TFriendLock::TFriendLock(const TFriendLock& tfl) :
  fTree(tfl.fTree),
  fMethodBit(tfl.fMethodBit),
  fPrevious(tfl.fPrevious)
{
   //copy constructor
}

//______________________________________________________________________________
TTree::TFriendLock& TTree::TFriendLock::operator=(const TTree::TFriendLock& tfl)
{
   //assignment operator
   if(this!=&tfl) {
      fTree=tfl.fTree;
      fMethodBit=tfl.fMethodBit;
      fPrevious=tfl.fPrevious;
   }
   return *this;
}

//______________________________________________________________________________
TTree::TFriendLock::~TFriendLock()
{
   // Restore the state of tree the same as before we set the lock.

   if (fTree) {
      if (!fPrevious) {
         fTree->fFriendLockStatus &= ~(fMethodBit & kBitMask);
      }
   }
}

//______________________________________________________________________________
//  Helper class to iterate over cluster of baskets.

//______________________________________________________________________________
TTree::TClusterIterator::TClusterIterator(TTree *tree, Long64_t firstEntry) : fTree(tree), fClusterRange(0), fStartEntry(0), fNextEntry(0)
{
   // Regular constructor.
   // TTree is not set as const, since we might modify if it is a TChain.

   if ( fTree->GetAutoFlush() <= 0 ) {
      // Case of old files before November 9 2009
      fStartEntry = firstEntry;
   } else if (fTree->fNClusterRange) {
      // Find the correct cluster range.
      //
      // Since fClusterRangeEnd contains the inclusive upper end of the range, we need to search for the
      // range that was containing the previous entry and add 1 (because BinarySearch consider the values
      // to be the inclusive start of the bucket).
      fClusterRange = TMath::BinarySearch(fTree->fNClusterRange, fTree->fClusterRangeEnd, firstEntry - 1) + 1;

      Long64_t entryInRange;
      Long64_t pedestal;
      if (fClusterRange == 0) {
         pedestal = 0;
         entryInRange = firstEntry;
      } else {
         pedestal = fTree->fClusterRangeEnd[fClusterRange-1] + 1;
         entryInRange = firstEntry - pedestal;
      }
      Long64_t autoflush;
      if (fClusterRange == fTree->fNClusterRange) {
         autoflush = fTree->fAutoFlush;
      } else {
         autoflush = fTree->fClusterSize[fClusterRange];
      }
      if (autoflush == 0) {
         autoflush = GetEstimatedClusterSize();
      }
      fStartEntry = pedestal + entryInRange - entryInRange%autoflush;
   } else {
      fStartEntry = firstEntry - firstEntry%fTree->GetAutoFlush();
   }
   fNextEntry = fStartEntry; // Position correctly for the first call to Next()
}

//______________________________________________________________________________
Long64_t TTree::TClusterIterator::GetEstimatedClusterSize()
{
   // In the case where the cluster size was not fixed (old files and
   // case where autoflush was explicitly set to zero, we need estimate
   // a cluster size in relation to the size of the cache.

   Long64_t zipBytes = fTree->GetZipBytes();
   if (zipBytes == 0) {
      return fTree->GetEntries() - 1;
   } else {
      Long64_t clusterEstimate = 1;
      Long64_t cacheSize = fTree->GetCacheSize();
      if (cacheSize == 0) {
         // Humm ... let's double check on the file.
         TFile *file = fTree->GetCurrentFile();
         if (file) {
            TFileCacheRead *cache = file->GetCacheRead(fTree);
            if (cache) {
               cacheSize = cache->GetBufferSize();
            }
         }
      }
      if (cacheSize > 0) {
         clusterEstimate = fTree->GetEntries() * cacheSize / zipBytes;
         if (clusterEstimate == 0)
            clusterEstimate = 1;
      }
      return clusterEstimate;
   }
}

//______________________________________________________________________________
Long64_t TTree::TClusterIterator::Next()
{
   // Move on to the next cluster and return the starting entry
   // of this next cluster

   fStartEntry = fNextEntry;
   if ( fTree->GetAutoFlush() <= 0 ) {
      // Case of old files before November 9 2009
      Long64_t clusterEstimate = GetEstimatedClusterSize();
      fNextEntry = fStartEntry + clusterEstimate;
   } else {
      if (fClusterRange == fTree->fNClusterRange) {
         // We are looking at the last range ; its size
         // is defined by AutoFlush itself and goes to the GetEntries.
         fNextEntry += fTree->GetAutoFlush();
      } else {
         if (fStartEntry > fTree->fClusterRangeEnd[fClusterRange]) {
            ++fClusterRange;
         }
         if (fClusterRange == fTree->fNClusterRange) {
            // We are looking at the last range which size
            // is defined by AutoFlush itself and goes to the GetEntries.
            fNextEntry += fTree->GetAutoFlush();
         } else {
            Long64_t clusterSize = fTree->fClusterSize[fClusterRange];
            if (clusterSize == 0) {
               clusterSize = GetEstimatedClusterSize();
            }
            fNextEntry += clusterSize;
            if (fNextEntry > fTree->fClusterRangeEnd[fClusterRange]) {
               // The last cluster of the range was a partial cluster,
               // so the next cluster starts at the beginning of the
               // next range.
               fNextEntry = fTree->fClusterRangeEnd[fClusterRange] + 1;
            }
         }
      }
   }
   if (fNextEntry > fTree->GetEntries()) {
      fNextEntry = fTree->GetEntries();
   }
   return fStartEntry;
}

//
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
//

//______________________________________________________________________________
TTree::TTree()
: TNamed()
, TAttLine()
, TAttFill()
, TAttMarker()
, fEntries(0)
, fTotBytes(0)
, fZipBytes(0)
, fSavedBytes(0)
, fFlushedBytes(0)
, fWeight(1)
, fTimerInterval(0)
, fScanField(25)
, fUpdate(0)
, fDefaultEntryOffsetLen(1000)
, fNClusterRange(0)
, fMaxClusterRange(0)
, fMaxEntries(0)
, fMaxEntryLoop(0)
, fMaxVirtualSize(0)
, fAutoSave( -300000000)
, fAutoFlush(-30000000)
, fEstimate(1000000)
, fClusterRangeEnd(0)
, fClusterSize(0)
, fCacheSize(0)
, fChainOffset(0)
, fReadEntry(-1)
, fTotalBuffers(0)
, fPacketSize(100)
, fNfill(0)
, fDebug(0)
, fDebugMin(0)
, fDebugMax(9999999)
, fMakeClass(0)
, fFileNumber(0)
, fNotify(0)
, fDirectory(0)
, fBranches()
, fLeaves()
, fAliases(0)
, fEventList(0)
, fEntryList(0)
, fIndexValues()
, fIndex()
, fTreeIndex(0)
, fFriends(0)
, fPerfStats(0)
, fUserInfo(0)
, fPlayer(0)
, fClones(0)
, fBranchRef(0)
, fFriendLockStatus(0)
, fTransientBuffer(0)
, fCacheDoAutoInit(kTRUE)
, fCacheUserSet(kFALSE)
{
   // Default constructor and I/O constructor.
   //
   // Note: We do *not* insert ourself into the current directory.
   //

   fMaxEntries = 1000000000;
   fMaxEntries *= 1000;

   fMaxEntryLoop = 1000000000;
   fMaxEntryLoop *= 1000;

   fBranches.SetOwner(kTRUE);
}

//______________________________________________________________________________
TTree::TTree(const char* name, const char* title, Int_t splitlevel /* = 99 */)
: TNamed(name, title)
, TAttLine()
, TAttFill()
, TAttMarker()
, fEntries(0)
, fTotBytes(0)
, fZipBytes(0)
, fSavedBytes(0)
, fFlushedBytes(0)
, fWeight(1)
, fTimerInterval(0)
, fScanField(25)
, fUpdate(0)
, fDefaultEntryOffsetLen(1000)
, fNClusterRange(0)
, fMaxClusterRange(0)
, fMaxEntries(0)
, fMaxEntryLoop(0)
, fMaxVirtualSize(0)
, fAutoSave( -300000000)
, fAutoFlush(-30000000)
, fEstimate(1000000)
, fClusterRangeEnd(0)
, fClusterSize(0)
, fCacheSize(0)
, fChainOffset(0)
, fReadEntry(-1)
, fTotalBuffers(0)
, fPacketSize(100)
, fNfill(0)
, fDebug(0)
, fDebugMin(0)
, fDebugMax(9999999)
, fMakeClass(0)
, fFileNumber(0)
, fNotify(0)
, fDirectory(0)
, fBranches()
, fLeaves()
, fAliases(0)
, fEventList(0)
, fEntryList(0)
, fIndexValues()
, fIndex()
, fTreeIndex(0)
, fFriends(0)
, fPerfStats(0)
, fUserInfo(0)
, fPlayer(0)
, fClones(0)
, fBranchRef(0)
, fFriendLockStatus(0)
, fTransientBuffer(0)
, fCacheDoAutoInit(kTRUE)
, fCacheUserSet(kFALSE)
{
   // Normal tree constructor.
   //
   // The tree is created in the current directory.
   // Use the various functions Branch below to add branches to this tree.
   //
   // If the first character of title is a "/", the function assumes a folder name.
   // In this case, it creates automatically branches following the folder hierarchy.
   // splitlevel may be used in this case to control the split level.

   // TAttLine state.
   SetLineColor(gStyle->GetHistLineColor());
   SetLineStyle(gStyle->GetHistLineStyle());
   SetLineWidth(gStyle->GetHistLineWidth());

   // TAttFill state.
   SetFillColor(gStyle->GetHistFillColor());
   SetFillStyle(gStyle->GetHistFillStyle());

   // TAttMarkerState.
   SetMarkerColor(gStyle->GetMarkerColor());
   SetMarkerStyle(gStyle->GetMarkerStyle());
   SetMarkerSize(gStyle->GetMarkerSize());

   fMaxEntries = 1000000000;
   fMaxEntries *= 1000;

   fMaxEntryLoop = 1000000000;
   fMaxEntryLoop *= 1000;

   // Insert ourself into the current directory.
   // FIXME: This is very annoying behaviour, we should
   //        be able to choose to not do this like we
   //        can with a histogram.
   fDirectory = gDirectory;
   if (fDirectory) fDirectory->Append(this);

   fBranches.SetOwner(kTRUE);

   // If title starts with "/" and is a valid folder name, a superbranch
   // is created.
   // FIXME: Why?
   if (strlen(title) > 2) {
      if (title[0] == '/') {
         Branch(title+1,32000,splitlevel);
      }
   }
}

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

   if (fDirectory) {
      // We are in a directory, which may possibly be a file.
      if (fDirectory->GetList()) {
         // Remove us from the directory listing.
         fDirectory->Remove(this);
      }
      //delete the file cache if it points to this Tree
      TFile *file = fDirectory->GetFile();
      MoveReadCache(file,0);
   }
   // We don't own the leaves in fLeaves, the branches do.
   fLeaves.Clear();
   // I'm ready to destroy any objects allocated by
   // SetAddress() by my branches.  If I have clones,
   // tell them to zero their pointers to this shared
   // memory.
   if (fClones && fClones->GetEntries()) {
      // I have clones.
      // I am about to delete the objects created by
      // SetAddress() which we are sharing, so tell
      // the clones to release their pointers to them.
      for (TObjLink* lnk = fClones->FirstLink(); lnk; lnk = lnk->Next()) {
         TTree* clone = (TTree*) lnk->GetObject();
         // clone->ResetBranchAddresses();

         // Reset only the branch we have set the address of.
         CopyAddresses(clone,kTRUE);
      }
   }
   // Get rid of our branches, note that this will also release
   // any memory allocated by TBranchElement::SetAddress().
   fBranches.Delete();
   // FIXME: We must consider what to do with the reset of these if we are a clone.
   delete fPlayer;
   fPlayer = 0;
   if (fFriends) {
      fFriends->Delete();
      delete fFriends;
      fFriends = 0;
   }
   if (fAliases) {
      fAliases->Delete();
      delete fAliases;
      fAliases = 0;
   }
   if (fUserInfo) {
      fUserInfo->Delete();
      delete fUserInfo;
      fUserInfo = 0;
   }
   if (fClones) {
      // Clone trees should no longer be removed from fClones when they are deleted.
      gROOT->GetListOfCleanups()->Remove(fClones);
      // Note: fClones does not own its content.
      delete fClones;
      fClones = 0;
   }
   if (fEntryList) {
      if (fEntryList->TestBit(kCanDelete) && fEntryList->GetDirectory()==0) {
         // Delete the entry list if it is marked to be deleted and it is not also
         // owned by a directory.  (Otherwise we would need to make sure that a
         // TDirectoryFile that has a TTree in it does a 'slow' TList::Delete.
         delete fEntryList;
         fEntryList=0;
      }
   }
   delete fTreeIndex;
   fTreeIndex = 0;
   delete fBranchRef;
   fBranchRef = 0;
   delete [] fClusterRangeEnd;
   fClusterRangeEnd = 0;
   delete [] fClusterSize;
   fClusterSize = 0;
   // Must be done after the destruction of friends.
   // Note: We do *not* own our directory.
   fDirectory = 0;

   if (fTransientBuffer) {
      delete fTransientBuffer;
      fTransientBuffer = 0;
   }
}

//______________________________________________________________________________
TBuffer* TTree::GetTransientBuffer(Int_t size)
{
    // Returns the transient buffer currently used by this TTree for reading/writing baskets.

   if (fTransientBuffer) {
      if (fTransientBuffer->BufferSize() < size) {
         fTransientBuffer->Expand(size);
      }
      return fTransientBuffer;
   }
   fTransientBuffer = new TBufferFile(TBuffer::kRead, size);
   return fTransientBuffer;
}

//______________________________________________________________________________
Int_t TTree::AddBranchToCache(const char*bname, Bool_t subbranches)
{
   // Add branch with name bname to the Tree cache.
   // If bname="*" all branches are added to the cache.
   // if subbranches is true all the branches of the subbranches are
   // also put to the cache.
   // Returns  0 branch added or already included
   //         -1 on error

   if (!GetTree()) {
      if (LoadTree(0)<0) {
         Error("AddBranchToCache","Could not load a tree");
         return -1;
      }
   }
   if (GetTree()) {
      if (GetTree() != this) {
         return GetTree()->AddBranchToCache(bname, subbranches);
      }
   } else {
      Error("AddBranchToCache", "No tree is available. Branch was not added to the cache");
      return -1;
   }

   TFile *f = GetCurrentFile();
   if (!f) {
      Error("AddBranchToCache", "No file is available. Branch was not added to the cache");
      return -1;
   }
   TTreeCache *tc = GetReadCache(f,kTRUE);
   if (!tc) {
      Error("AddBranchToCache", "No cache is available, branch not added");
      return -1;
   }
   return tc->AddBranch(bname,subbranches);
}

//______________________________________________________________________________
Int_t TTree::AddBranchToCache(TBranch *b, Bool_t subbranches)
{
   // Add branch b to the Tree cache.
   // if subbranches is true all the branches of the subbranches are
   // also put to the cache.
   // Returns  0 branch added or already included
   //         -1 on error

   if (!GetTree()) {
      if (LoadTree(0)<0) {
         Error("AddBranchToCache","Could not load a tree");
         return -1;
      }
   }
   if (GetTree()) {
      if (GetTree() != this) {
         Int_t res = GetTree()->AddBranchToCache(b, subbranches);
         if (res<0) {
             Error("AddBranchToCache", "Error adding branch");
         }
         return res;
      }
   } else {
      Error("AddBranchToCache", "No tree is available. Branch was not added to the cache");
      return -1;
   }

   TFile *f = GetCurrentFile();
   if (!f) {
      Error("AddBranchToCache", "No file is available. Branch was not added to the cache");
      return -1;
   }
   TTreeCache *tc = GetReadCache(f,kTRUE);
   if (!tc) {
      Error("AddBranchToCache", "No cache is available, branch not added");
      return -1;
   }
   return tc->AddBranch(b,subbranches);
}

//______________________________________________________________________________
Int_t TTree::DropBranchFromCache(const char*bname, Bool_t subbranches)
{
   // Remove the branch with name 'bname' from the Tree cache.
   // If bname="*" all branches are removed from the cache.
   // if subbranches is true all the branches of the subbranches are
   // also removed from the cache.
   // Returns  0 branch dropped or not in cache
   //         -1 on error

   if (!GetTree()) {
      if (LoadTree(0)<0) {
         Error("DropBranchFromCache","Could not load a tree");
         return -1;
      }
   }
   if (GetTree()) {
      if (GetTree() != this) {
         return GetTree()->DropBranchFromCache(bname, subbranches);
      }
   } else {
      Error("DropBranchFromCache", "No tree is available. Branch was not dropped from the cache");
      return -1;
   }

   TFile *f = GetCurrentFile();
   if (!f) {
      Error("DropBranchFromCache", "No file is available. Branch was not dropped from the cache");
      return -1;
   }
   TTreeCache *tc = GetReadCache(f,kTRUE);
   if (!tc) {
      Error("DropBranchFromCache", "No cache is available, branch not dropped");
      return -1;
   }
   return tc->DropBranch(bname,subbranches);
}

//______________________________________________________________________________
Int_t TTree::DropBranchFromCache(TBranch *b, Bool_t subbranches)
{
   // Remove the branch b from the Tree cache.
   // if subbranches is true all the branches of the subbranches are
   // also removed from the cache.
   // Returns  0 branch dropped or not in cache
   //         -1 on error

   if (!GetTree()) {
      if (LoadTree(0)<0) {
         Error("DropBranchFromCache","Could not load a tree");
         return -1;
      }
   }
   if (GetTree()) {
      if (GetTree() != this) {
         Int_t res = GetTree()->DropBranchFromCache(b, subbranches);
         if (res<0) {
             Error("DropBranchFromCache", "Error dropping branch");
         }
         return res;
      }
   } else {
      Error("DropBranchFromCache", "No tree is available. Branch was not dropped from the cache");
      return -1;
   }

   TFile *f = GetCurrentFile();
   if (!f) {
      Error("DropBranchFromCache", "No file is available. Branch was not dropped from the cache");
      return -1;
   }
   TTreeCache *tc = GetReadCache(f,kTRUE);
   if (!tc) {
      Error("DropBranchFromCache", "No cache is available, branch not dropped");
      return -1;
   }
   return tc->DropBranch(b,subbranches);
}


//______________________________________________________________________________
void TTree::AddClone(TTree* clone)
{
   // Add a cloned tree to our list of trees to be notified whenever we change
   // our branch addresses or when we are deleted.

   if (!fClones) {
      fClones = new TList();
      fClones->SetOwner(false);
      // So that the clones are automatically removed from the list when
      // they are deleted.
      gROOT->GetListOfCleanups()->Add(fClones);
   }
   if (!fClones->FindObject(clone)) {
      fClones->Add(clone);
   }
}


//______________________________________________________________________________
TFriendElement* TTree::AddFriend(const char* treename, const char* filename)
{
   // Add a TFriendElement to the list of friends.
   //
   // This function:
   //   -opens a file if filename is specified
   //   -reads a Tree with name treename from the file (current directory)
   //   -adds the Tree to the list of friends
   // see other AddFriend functions
   //
   // A TFriendElement TF describes a TTree object TF in a file.
   // When a TFriendElement TF is added to the the list of friends of an
   // existing TTree T, any variable from TF can be referenced in a query
   // to T.
   //
   //   A tree keeps a list of friends. In the context of a tree (or a chain),
   // friendship means unrestricted access to the friends data. In this way
   // it is much like adding another branch to the tree without taking the risk
   // of damaging it. To add a friend to the list, you can use the TTree::AddFriend
   // method.  The tree in the diagram below has two friends (friend_tree1 and
   // friend_tree2) and now has access to the variables a,b,c,i,j,k,l and m.
   //
   //Begin_Html
   /*
   <img src="gif/tree_friend1.gif">
   */
   //End_Html
   //
   // The AddFriend method has two parameters, the first is the tree name and the
   // second is the name of the ROOT file where the friend tree is saved.
   // AddFriend automatically opens the friend file. If no file name is given,
   // the tree called ft1 is assumed to be in the same file as the original tree.
   //
   // tree.AddFriend("ft1","friendfile1.root");
   // If the friend tree has the same name as the original tree, you can give it
   // an alias in the context of the friendship:
   //
   // tree.AddFriend("tree1 = tree","friendfile1.root");
   // Once the tree has friends, we can use TTree::Draw as if the friend's
   // variables were in the original tree. To specify which tree to use in
   // the Draw method, use the syntax:
   //
   // <treeName>.<branchname>.<varname>
   // If the variablename is enough to uniquely identify the variable, you can
   // leave out the tree and/or branch name.
   // For example, these commands generate a 3-d scatter plot of variable "var"
   // in the TTree tree versus variable v1 in TTree ft1 versus variable v2 in
   // TTree ft2.
   //
   // tree.AddFriend("ft1","friendfile1.root");
   // tree.AddFriend("ft2","friendfile2.root");
   // tree.Draw("var:ft1.v1:ft2.v2");
   //
   //Begin_Html
   /*
   <img src="gif/tree_friend2.gif">
   */
   //End_Html
   //
   // The picture illustrates the access of the tree and its friends with a
   // Draw command.
   // When AddFriend is called, the ROOT file is automatically opened and the
   // friend tree (ft1) is read into memory. The new friend (ft1) is added to
   // the list of friends of tree.
   // The number of entries in the friend must be equal or greater to the number
   // of entries of the original tree. If the friend tree has fewer entries a
   // warning is given and the missing entries are not included in the histogram.
   // To retrieve the list of friends from a tree use TTree::GetListOfFriends.
   // When the tree is written to file (TTree::Write), the friends list is saved
   // with it. And when the tree is retrieved, the trees on the friends list are
   // also retrieved and the friendship restored.
   // When a tree is deleted, the elements of the friend list are also deleted.
   // It is possible to declare a friend tree that has the same internal
   // structure (same branches and leaves) as the original tree, and compare the
   // same values by specifying the tree.
   //
   //  tree.Draw("var:ft1.var:ft2.var")

   //if (kAddFriend & fFriendLockStatus)

   if (!fFriends) {
      fFriends = new TList();
   }
   TFriendElement* fe = new TFriendElement(this, treename, filename);

   fFriends->Add(fe);
   TTree* t = fe->GetTree();
   if (t) {
      if (!t->GetTreeIndex() && (t->GetEntries() < fEntries)) {
         Warning("AddFriend", "FriendElement %s in file %s has less entries %lld than its parent Tree: %lld", treename, filename, t->GetEntries(), fEntries);
      }
   } else {
      Warning("AddFriend", "Cannot add FriendElement %s in file %s", treename, filename);
   }
   return fe;
}

//______________________________________________________________________________
TFriendElement* TTree::AddFriend(const char* treename, TFile* file)
{
   // Add a TFriendElement to the list of friends.
   //
   // The TFile is managed by the user (e.g. the user must delete the file).
   // For complete description see AddFriend(const char *, const char *).
   // This function:
   //   -reads a Tree with name treename from the file
   //   -adds the Tree to the list of friends

   if (!fFriends) {
      fFriends = new TList();
   }
   TFriendElement *fe = new TFriendElement(this, treename, file);
   R__ASSERT(fe);
   fFriends->Add(fe);
   TTree *t = fe->GetTree();
   if (t) {
      if (!t->GetTreeIndex() && (t->GetEntries() < fEntries)) {
         Warning("AddFriend", "FriendElement %s in file %s has less entries %lld than its parent tree: %lld", treename, file->GetName(), t->GetEntries(), fEntries);
      }
   } else {
      Warning("AddFriend", "unknown tree '%s' in file '%s'", treename, file->GetName());
   }
   return fe;
}

//______________________________________________________________________________
TFriendElement* TTree::AddFriend(TTree* tree, const char* alias, Bool_t warn)
{
   // Add a TFriendElement to the list of friends.
   //
   // The TTree is managed by the user (e.g., the user must delete the file).
   // For a complete description see AddFriend(const char *, const char *).

   if (!tree) {
      return 0;
   }
   if (!fFriends) {
      fFriends = new TList();
   }
   TFriendElement* fe = new TFriendElement(this, tree, alias);
   R__ASSERT(fe); // this assert is for historical reasons. Don't remove it unless you understand all the consequences.
   fFriends->Add(fe);
   TTree* t = fe->GetTree();
   if (warn && (t->GetEntries() < fEntries)) {
      Warning("AddFriend", "FriendElement '%s' in file '%s' has less entries %lld than its parent tree: %lld",
              tree->GetName(), fe->GetFile() ? fe->GetFile()->GetName() : "(memory resident)", t->GetEntries(), fEntries);
   }
   return fe;
}

//______________________________________________________________________________
Long64_t TTree::AutoSave(Option_t* option)
{
   // AutoSave tree header every fAutoSave bytes.
   //
   //   When large Trees are produced, it is safe to activate the AutoSave
   //   procedure. Some branches may have buffers holding many entries.
   //   If fAutoSave is negative, AutoSave is automatically called by
   //   TTree::Fill when the number of bytes generated since the previous
   //   AutoSave is greater than -fAutoSave bytes.
   //   If fAutoSave is positive, AutoSave is automatically called by
   //   TTree::Fill every N entries.
   //   This function may also be invoked by the user.
   //   Each AutoSave generates a new key on the file.
   //   Once the key with the tree header has been written, the previous cycle
   //   (if any) is deleted.
   //
   //   Note that calling TTree::AutoSave too frequently (or similarly calling
   //   TTree::SetAutoSave with a small value) is an expensive operation.
   //   You should make tests for your own application to find a compromise
   //   between speed and the quantity of information you may loose in case of
   //   a job crash.
   //
   //   In case your program crashes before closing the file holding this tree,
   //   the file will be automatically recovered when you will connect the file
   //   in UPDATE mode.
   //   The Tree will be recovered at the status corresponding to the last AutoSave.
   //
   //   if option contains "SaveSelf", gDirectory->SaveSelf() is called.
   //   This allows another process to analyze the Tree while the Tree is being filled.
   //
   //   if option contains "FlushBaskets", TTree::FlushBaskets is called and all
   //   the current basket are closed-out and written to disk individually.
   //
   //   By default the previous header is deleted after having written the new header.
   //   if option contains "Overwrite", the previous Tree header is deleted
   //   before written the new header. This option is slightly faster, but
   //   the default option is safer in case of a problem (disk quota exceeded)
   //   when writing the new header.
   //
   //   The function returns the number of bytes written to the file.
   //   if the number of bytes is null, an error has occurred while writing
   //   the header to the file.
   //
   //   How to write a Tree in one process and view it from another process
   //   ===================================================================
   //   The following two scripts illustrate how to do this.
   //   The script treew.C is executed by process1, treer.C by process2
   //
   //   ----- script treew.C
   //   void treew() {
   //     TFile f("test.root","recreate");
   //     TNtuple *ntuple = new TNtuple("ntuple","Demo","px:py:pz:random:i");
   //     Float_t px, py, pz;
   //     for ( Int_t i=0; i<10000000; i++) {
   //        gRandom->Rannor(px,py);
   //        pz = px*px + py*py;
   //        Float_t random = gRandom->Rndm(1);
   //        ntuple->Fill(px,py,pz,random,i);
   //        if (i%1000 == 1) ntuple->AutoSave("SaveSelf");
   //     }
   //   }
   //
   //   ----- script treer.C
   //   void treer() {
   //      TFile f("test.root");
   //      TTree *ntuple = (TTree*)f.Get("ntuple");
   //      TCanvas c1;
   //      Int_t first = 0;
   //      while(1) {
   //         if (first == 0) ntuple->Draw("px>>hpx", "","",10000000,first);
   //         else            ntuple->Draw("px>>+hpx","","",10000000,first);
   //         first = (Int_t)ntuple->GetEntries();
   //         c1.Update();
   //         gSystem->Sleep(1000); //sleep 1 second
   //         ntuple->Refresh();
   //      }
   //   }

   if (!fDirectory || fDirectory == gROOT || !fDirectory->IsWritable()) return 0;
   if (gDebug > 0) {
      printf("AutoSave Tree:%s after %lld bytes written\n",GetName(),fTotBytes);
   }
   TString opt = option;
   opt.ToLower();

   if (opt.Contains("flushbaskets")) {
      if (gDebug > 0) printf("AutoSave:  calling FlushBaskets \n");
      FlushBaskets();
   }

   fSavedBytes = fZipBytes;

   TKey *key = (TKey*)fDirectory->GetListOfKeys()->FindObject(GetName());
   Long64_t nbytes;
   if (opt.Contains("overwrite")) {
      nbytes = fDirectory->WriteTObject(this,"","overwrite");
   } else {
      nbytes = fDirectory->WriteTObject(this); //nbytes will be 0 if Write failed (disk space exceeded)
      if (nbytes && key) {
         key->Delete();
         delete key;
      }
   }
   // save StreamerInfo
   TFile *file = fDirectory->GetFile();
   if (file) file->WriteStreamerInfo();

   if (opt.Contains("saveself")) {
      fDirectory->SaveSelf();
      //the following line is required in case GetUserInfo contains a user class
      //for which the StreamerInfo must be written. One could probably be a bit faster (Rene)
      if (file) file->WriteHeader();
   }

   return nbytes;
}

namespace {
   // This error message is repeated several times in the code. We write it once.
   const char* writeStlWithoutProxyMsg = "The class requested (%s) for the branch \"%s\""
                                      " is an instance of an stl collection and does not have a compiled CollectionProxy."
                                      " Please generate the dictionary for this collection (%s) to avoid to write corrupted data.";
}

//______________________________________________________________________________
TBranch* TTree::BranchImp(const char* branchname, const char* classname, TClass* ptrClass, void* addobj, Int_t bufsize, Int_t splitlevel)
{
   // Same as TTree::Branch() with added check that addobj matches className.
   //
   // See TTree::Branch() for other details.
   //

   TClass* claim = TClass::GetClass(classname);
   if (!ptrClass) {
      if (claim && claim->GetCollectionProxy() && dynamic_cast<TEmulatedCollectionProxy*>(claim->GetCollectionProxy())) {
         Error("Branch", writeStlWithoutProxyMsg,
               claim->GetName(), branchname, claim->GetName());
         return 0;
      }
      return Branch(branchname, classname, (void*) addobj, bufsize, splitlevel);
   }
   TClass* actualClass = 0;
   void** addr = (void**) addobj;
   if (addr) {
      actualClass = ptrClass->GetActualClass(*addr);
   }
   if (ptrClass && claim) {
      if (!(claim->InheritsFrom(ptrClass) || ptrClass->InheritsFrom(claim))) {
         // Note we currently do not warn in case of splicing or over-expectation).
         if (claim->IsLoaded() && ptrClass->IsLoaded() && strcmp( claim->GetTypeInfo()->name(), ptrClass->GetTypeInfo()->name() ) == 0) {
            // The type is the same according to the C++ type_info, we must be in the case of
            // a template of Double32_t.  This is actually a correct case.
         } else {
            Error("Branch", "The class requested (%s) for \"%s\" is different from the type of the pointer passed (%s)",
                  claim->GetName(), branchname, ptrClass->GetName());
         }
      } else if (actualClass && (claim != actualClass) && !actualClass->InheritsFrom(claim)) {
         if (claim->IsLoaded() && actualClass->IsLoaded() && strcmp( claim->GetTypeInfo()->name(), actualClass->GetTypeInfo()->name() ) == 0) {
            // The type is the same according to the C++ type_info, we must be in the case of
            // a template of Double32_t.  This is actually a correct case.
         } else {
            Error("Branch", "The actual class (%s) of the object provided for the definition of the branch \"%s\" does not inherit from %s",
                  actualClass->GetName(), branchname, claim->GetName());
         }
      }
   }
   if (claim && claim->GetCollectionProxy() && dynamic_cast<TEmulatedCollectionProxy*>(claim->GetCollectionProxy())) {
      Error("Branch", writeStlWithoutProxyMsg,
            claim->GetName(), branchname, claim->GetName());
      return 0;
   }
   return Branch(branchname, classname, (void*) addobj, bufsize, splitlevel);
}

//______________________________________________________________________________
TBranch* TTree::BranchImp(const char* branchname, TClass* ptrClass, void* addobj, Int_t bufsize, Int_t splitlevel)
{
   // Same as TTree::Branch but automatic detection of the class name.
   // See TTree::Branch for other details.

   if (!ptrClass) {
      Error("Branch", "The pointer specified for %s is not of a class known to ROOT", branchname);
      return 0;
   }
   TClass* actualClass = 0;
   void** addr = (void**) addobj;
   if (addr && *addr) {
      actualClass = ptrClass->GetActualClass(*addr);
      if (!actualClass) {
         Warning("Branch", "The actual TClass corresponding to the object provided for the definition of the branch \"%s\" is missing.\n\tThe object will be truncated down to its %s part",
                 branchname, ptrClass->GetName());
         actualClass = ptrClass;
      } else if ((ptrClass != actualClass) && !actualClass->InheritsFrom(ptrClass)) {
         Error("Branch", "The actual class (%s) of the object provided for the definition of the branch \"%s\" does not inherit from %s", actualClass->GetName(), branchname, ptrClass->GetName());
         return 0;
      }
   } else {
      actualClass = ptrClass;
   }
   if (actualClass && actualClass->GetCollectionProxy() && dynamic_cast<TEmulatedCollectionProxy*>(actualClass->GetCollectionProxy())) {
      Error("Branch", writeStlWithoutProxyMsg,
            actualClass->GetName(), branchname, actualClass->GetName());
      return 0;
   }
   return Branch(branchname, actualClass->GetName(), (void*) addobj, bufsize, splitlevel);
}

//______________________________________________________________________________
TBranch* TTree::BranchImpRef(const char* branchname, const char *classname, TClass* ptrClass, void *addobj, Int_t bufsize, Int_t splitlevel)
{
   // Same as TTree::Branch but automatic detection of the class name.
   // See TTree::Branch for other details.

   TClass* claim = TClass::GetClass(classname);
   if (!ptrClass) {
      if (claim && claim->GetCollectionProxy() && dynamic_cast<TEmulatedCollectionProxy*>(claim->GetCollectionProxy())) {
         Error("Branch", writeStlWithoutProxyMsg,
               claim->GetName(), branchname, claim->GetName());
         return 0;
      } else if (claim == 0) {
         Error("Branch", "The pointer specified for %s is not of a class known to ROOT and %s is not a known class", branchname, classname);
         return 0;
      }
      ptrClass = claim;
   }
   TClass* actualClass = 0;
   if (!addobj) {
      Error("Branch", "Reference interface requires a valid object (for branch: %s)!", branchname);
      return 0;
   }
   actualClass = ptrClass->GetActualClass(addobj);
   if (ptrClass && claim) {
      if (!(claim->InheritsFrom(ptrClass) || ptrClass->InheritsFrom(claim))) {
         // Note we currently do not warn in case of splicing or over-expectation).
         if (claim->IsLoaded() && ptrClass->IsLoaded() && strcmp( claim->GetTypeInfo()->name(), ptrClass->GetTypeInfo()->name() ) == 0) {
            // The type is the same according to the C++ type_info, we must be in the case of
            // a template of Double32_t.  This is actually a correct case.
         } else {
            Error("Branch", "The class requested (%s) for \"%s\" is different from the type of the object passed (%s)",
                  claim->GetName(), branchname, ptrClass->GetName());
         }
      } else if (actualClass && (claim != actualClass) && !actualClass->InheritsFrom(claim)) {
         if (claim->IsLoaded() && actualClass->IsLoaded() && strcmp( claim->GetTypeInfo()->name(), actualClass->GetTypeInfo()->name() ) == 0) {
            // The type is the same according to the C++ type_info, we must be in the case of
            // a template of Double32_t.  This is actually a correct case.
         } else {
            Error("Branch", "The actual class (%s) of the object provided for the definition of the branch \"%s\" does not inherit from %s",
                  actualClass->GetName(), branchname, claim->GetName());
         }
      }
   }
   if (!actualClass) {
      Warning("Branch", "The actual TClass corresponding to the object provided for the definition of the branch \"%s\" is missing.\n\tThe object will be truncated down to its %s part",
              branchname, ptrClass->GetName());
      actualClass = ptrClass;
   } else if ((ptrClass != actualClass) && !actualClass->InheritsFrom(ptrClass)) {
      Error("Branch", "The actual class (%s) of the object provided for the definition of the branch \"%s\" does not inherit from %s", actualClass->GetName(), branchname, ptrClass->GetName());
      return 0;
   }
   if (actualClass && actualClass->GetCollectionProxy() && dynamic_cast<TEmulatedCollectionProxy*>(actualClass->GetCollectionProxy())) {
      Error("Branch", writeStlWithoutProxyMsg,
            actualClass->GetName(), branchname, actualClass->GetName());
      return 0;
   }
   return BronchExec(branchname, actualClass->GetName(), (void*) addobj, kFALSE, bufsize, splitlevel);
}

//______________________________________________________________________________
TBranch* TTree::BranchImpRef(const char* branchname, TClass* ptrClass, EDataType datatype, void* addobj, Int_t bufsize, Int_t splitlevel)
{
   // Same as TTree::Branch but automatic detection of the class name.
   // See TTree::Branch for other details.

   if (!ptrClass) {
      if (datatype == kOther_t || datatype == kNoType_t) {
         Error("Branch", "The pointer specified for %s is not of a class or type known to ROOT", branchname);
      } else {
         TString varname; varname.Form("%s/%c",branchname,DataTypeToChar(datatype));
         return Branch(branchname,addobj,varname.Data(),bufsize);
      }
      return 0;
   }
   TClass* actualClass = 0;
   if (!addobj) {
      Error("Branch", "Reference interface requires a valid object (for branch: %s)!", branchname);
      return 0;
   }
   actualClass = ptrClass->GetActualClass(addobj);
   if (!actualClass) {
      Warning("Branch", "The actual TClass corresponding to the object provided for the definition of the branch \"%s\" is missing.\n\tThe object will be truncated down to its %s part",
              branchname, ptrClass->GetName());
      actualClass = ptrClass;
   } else if ((ptrClass != actualClass) && !actualClass->InheritsFrom(ptrClass)) {
      Error("Branch", "The actual class (%s) of the object provided for the definition of the branch \"%s\" does not inherit from %s", actualClass->GetName(), branchname, ptrClass->GetName());
      return 0;
   }
   if (actualClass && actualClass->GetCollectionProxy() && dynamic_cast<TEmulatedCollectionProxy*>(actualClass->GetCollectionProxy())) {
      Error("Branch", writeStlWithoutProxyMsg,
            actualClass->GetName(), branchname, actualClass->GetName());
      return 0;
   }
   return BronchExec(branchname, actualClass->GetName(), (void*) addobj, kFALSE, bufsize, splitlevel);
}

//______________________________________________________________________________
Int_t TTree::Branch(TList* li, Int_t bufsize /* = 32000 */ , Int_t splitlevel /* = 99 */)
{
   // Deprecated function. Use next function instead.
   return Branch((TCollection*) li, bufsize, splitlevel);
}

//______________________________________________________________________________
Int_t TTree::Branch(TCollection* li, Int_t bufsize /* = 32000 */, Int_t splitlevel /* = 99 */, const char* name /* = "" */)
{
   // Create one branch for each element in the collection.
   //
   //   Each entry in the collection becomes a top level branch if the
   //   corresponding class is not a collection. If it is a collection, the entry
   //   in the collection becomes in turn top level branches, etc.
   //   The splitlevel is decreased by 1 every time a new collection is found.
   //   For example if list is a TObjArray*
   //     - if splitlevel = 1, one top level branch is created for each element
   //        of the TObjArray.
   //     - if splitlevel = 2, one top level branch is created for each array element.
   //       if, in turn, one of the array elements is a TCollection, one top level
   //       branch will be created for each element of this collection.
   //
   //   In case a collection element is a TClonesArray, the special Tree constructor
   //   for TClonesArray is called.
   //   The collection itself cannot be a TClonesArray.
   //
   //   The function returns the total number of branches created.
   //
   //   If name is given, all branch names will be prefixed with name_.
   //
   // IMPORTANT NOTE1: This function should not be called with splitlevel < 1.
   //
   // IMPORTANT NOTE2: The branches created by this function will have names
   // corresponding to the collection or object names. It is important
   // to give names to collections to avoid misleading branch names or
   // identical branch names. By default collections have a name equal to
   // the corresponding class name, e.g. the default name for a TList is "TList".
   //
   // And in general in any cases two or more master branches contain subbranches
   // with identical names, one must add a "." (dot) character at the end
   // of the master branch name. This will force the name of the subbranch
   // to be master.subbranch instead of simply subbranch.
   // This situation happens when the top level object (say event)
   // has two or more members referencing the same class.
   // For example, if a Tree has two branches B1 and B2 corresponding
   // to objects of the same class MyClass, one can do:
   //       tree.Branch("B1.","MyClass",&b1,8000,1);
   //       tree.Branch("B2.","MyClass",&b2,8000,1);
   // if MyClass has 3 members a,b,c, the two instructions above will generate
   // subbranches called B1.a, B1.b ,B1.c, B2.a, B2.b, B2.c
   //
   // Example--------------------------------------------------------------:
   /*
   {
         TTree T("T","test list");
         TList *list = new TList();

         TObjArray *a1 = new TObjArray();
         a1->SetName("a1");
         list->Add(a1);
         TH1F *ha1a = new TH1F("ha1a","ha1",100,0,1);
         TH1F *ha1b = new TH1F("ha1b","ha1",100,0,1);
         a1->Add(ha1a);
         a1->Add(ha1b);
         TObjArray *b1 = new TObjArray();
         b1->SetName("b1");
         list->Add(b1);
         TH1F *hb1a = new TH1F("hb1a","hb1",100,0,1);
         TH1F *hb1b = new TH1F("hb1b","hb1",100,0,1);
         b1->Add(hb1a);
         b1->Add(hb1b);

         TObjArray *a2 = new TObjArray();
         a2->SetName("a2");
         list->Add(a2);
         TH1S *ha2a = new TH1S("ha2a","ha2",100,0,1);
         TH1S *ha2b = new TH1S("ha2b","ha2",100,0,1);
         a2->Add(ha2a);
         a2->Add(ha2b);

         T.Branch(list,16000,2);
         T.Print();
   }
   */
   //----------------------------------------------------------------------

   if (!li) {
      return 0;
   }
   TObject* obj = 0;
   Int_t nbranches = GetListOfBranches()->GetEntries();
   if (li->InheritsFrom(TClonesArray::Class())) {
      Error("Branch", "Cannot call this constructor for a TClonesArray");
      return 0;
   }
   Int_t nch = strlen(name);
   TString branchname;
   TIter next(li);
   while ((obj = next())) {
      if ((splitlevel > 1) &&  obj->InheritsFrom(TCollection::Class()) && !obj->InheritsFrom(TClonesArray::Class())) {
         TCollection* col = (TCollection*) obj;
         if (nch) {
            branchname.Form("%s_%s_", name, col->GetName());
         } else {
            branchname.Form("%s_", col->GetName());
         }
         Branch(col, bufsize, splitlevel - 1, branchname);
      } else {
         if (nch && (name[nch-1] == '_')) {
            branchname.Form("%s%s", name, obj->GetName());
         } else {
            if (nch) {
               branchname.Form("%s_%s", name, obj->GetName());
            } else {
               branchname.Form("%s", obj->GetName());
            }
         }
         if (splitlevel > 99) {
            branchname += ".";
         }
         Bronch(branchname, obj->ClassName(), li->GetObjectRef(obj), bufsize, splitlevel - 1);
      }
   }
   return GetListOfBranches()->GetEntries() - nbranches;
}

//______________________________________________________________________________
Int_t TTree::Branch(const char* foldername, Int_t bufsize /* = 32000 */, Int_t splitlevel /* = 99 */)
{
   // Create one branch for each element in the folder.
   // Returns the total number of branches created.

   TObject* ob = gROOT->FindObjectAny(foldername);
   if (!ob) {
      return 0;
   }
   if (ob->IsA() != TFolder::Class()) {
      return 0;
   }
   Int_t nbranches = GetListOfBranches()->GetEntries();
   TFolder* folder = (TFolder*) ob;
   TIter next(folder->GetListOfFolders());
   TObject* obj = 0;
   char* curname = new char[1000];
   char occur[20];
   while ((obj = next())) {
      snprintf(curname,1000, "%s/%s", foldername, obj->GetName());
      if (obj->IsA() == TFolder::Class()) {
         Branch(curname, bufsize, splitlevel - 1);
      } else {
         void* add = (void*) folder->GetListOfFolders()->GetObjectRef(obj);
         for (Int_t i = 0; i < 1000; ++i) {
            if (curname[i] == 0) {
               break;
            }
            if (curname[i] == '/') {
               curname[i] = '.';
            }
         }
         Int_t noccur = folder->Occurence(obj);
         if (noccur > 0) {
            snprintf(occur,20, "_%d", noccur);
            strlcat(curname, occur,1000);
         }
         TBranchElement* br = (TBranchElement*) Bronch(curname, obj->ClassName(), add, bufsize, splitlevel - 1);
         if (br) br->SetBranchFolder();
      }
   }
   delete[] curname;
   return GetListOfBranches()->GetEntries() - nbranches;
}

//______________________________________________________________________________
TBranch* TTree::Branch(const char* name, void* address, const char* leaflist, Int_t bufsize /* = 32000 */)
{
   // Create a new TTree Branch.
   //
   //    This Branch constructor is provided to support non-objects in
   //    a Tree. The variables described in leaflist may be simple
   //    variables or structures.  // See the two following
   //    constructors for writing objects in a Tree.
   //
   //    By default the branch buffers are stored in the same file as the Tree.
   //    use TBranch::SetFile to specify a different file
   //
   //       * address is the address of the first item of a structure.
   //       * 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 may be 0,1 or 2 characters. 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.
   //         If leaf name has the form var[nelem], where nelem is a non-negative integer, then
   //            it is used as the fixed size of the array.
   //         If leaf name has the form of a multi-dimensional array (e.g. var[nelem][nelem2])
   //            where nelem and nelem2 are non-negative integer) 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.

   TBranch* branch = new TBranch(this, name, address, leaflist, bufsize);
   if (branch->IsZombie()) {
      delete branch;
      branch = 0;
      return 0;
   }
   fBranches.Add(branch);
   return branch;
}

//______________________________________________________________________________
TBranch* TTree::Branch(const char* name, const char* classname, void* addobj, Int_t bufsize /* = 32000 */, Int_t splitlevel /* = 99 */)
{
   // Create a new branch with the object of class classname at address addobj.
   //
   // WARNING:
   // Starting with Root version 3.01, the Branch function uses the new style
   // branches (TBranchElement). To get the old behaviour, you can:
   //   - call BranchOld or
   //   - call TTree::SetBranchStyle(0)
   //
   // Note that with the new style, classname does not need to derive from TObject.
   // It must derived from TObject if the branch style has been set to 0 (old)
   //
   // Note: See the comments in TBranchElement::SetAddress() for a more
   //       detailed discussion of the meaning of the addobj parameter in
   //       the case of new-style branches.
   //
   // Use splitlevel < 0 instead of splitlevel=0 when the class
   // has a custom Streamer
   //
   // Note: if the split level is set to the default (99),  TTree::Branch will
   // not issue a warning if the class can not be split.

   if (fgBranchStyle == 1) {
      return Bronch(name, classname, addobj, bufsize, splitlevel);
   } else {
      if (splitlevel < 0) {
         splitlevel = 0;
      }
      return BranchOld(name, classname, addobj, bufsize, splitlevel);
   }
}

//______________________________________________________________________________
TBranch* TTree::BranchOld(const char* name, const char* classname, void* addobj, Int_t bufsize /* = 32000 */, Int_t splitlevel /* = 1 */)
{
   // Create a new TTree BranchObject.
   //
   //    Build a TBranchObject for an object of class classname.
   //    addobj is the address of a pointer to an object of class classname.
   //    IMPORTANT: classname must derive from TObject.
   //    The class dictionary must be available (ClassDef in class header).
   //
   //    This option requires access to the library where the corresponding class
   //    is defined. Accessing one single data member in the object implies
   //    reading the full object.
   //    See the next Branch constructor for a more efficient storage
   //    in case the entry consists of arrays of identical objects.
   //
   //    By default the branch buffers are stored in the same file as the Tree.
   //    use TBranch::SetFile to specify a different file
   //
   //      IMPORTANT NOTE about branch names
   //    In case two or more master branches contain subbranches with
   //    identical names, one must add a "." (dot) character at the end
   //    of the master branch name. This will force the name of the subbranch
   //    to be master.subbranch instead of simply subbranch.
   //    This situation happens when the top level object (say event)
   //    has two or more members referencing the same class.
   //    For example, if a Tree has two branches B1 and B2 corresponding
   //    to objects of the same class MyClass, one can do:
   //       tree.Branch("B1.","MyClass",&b1,8000,1);
   //       tree.Branch("B2.","MyClass",&b2,8000,1);
   //    if MyClass has 3 members a,b,c, the two instructions above will generate
   //    subbranches called B1.a, B1.b ,B1.c, B2.a, B2.b, B2.c
   //
   //    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.

   TClass* cl = TClass::GetClass(classname);
   if (!cl) {
      Error("BranchOld", "Cannot find class: '%s'", classname);
      return 0;
   }
   if (!cl->IsTObject()) {
      if (fgBranchStyle == 0) {
        Fatal("BranchOld", "The requested class ('%s') does not inherit from TObject.\n"
              "\tfgBranchStyle is set to zero requesting by default to use BranchOld.\n"
              "\tIf this is intentional use Bronch instead of Branch or BranchOld.", classname);
      } else {
        Fatal("BranchOld", "The requested class ('%s') does not inherit from TObject.\n"
              "\tYou can not use BranchOld to store objects of this type.",classname);
      }
      return 0;
   }
   TBranch* branch = new TBranchObject(this, name, classname, addobj, bufsize, splitlevel);
   fBranches.Add(branch);
   if (!splitlevel) {
      return branch;
   }
   // We are going to fully split the class now.
   TObjArray* blist = branch->GetListOfBranches();
   const char* rdname = 0;
   const char* dname = 0;
   TString branchname;
   char** apointer = (char**) addobj;
   TObject* obj = (TObject*) *apointer;
   Bool_t delobj = kFALSE;
   if (!obj) {
      obj = (TObject*) cl->New();
      delobj = kTRUE;
   }
   // Build the StreamerInfo if first time for the class.
   BuildStreamerInfo(cl, obj);
   // Loop on all public data members of the class and its base classes.
   Int_t lenName = strlen(name);
   Int_t isDot = 0;
   if (name[lenName-1] == '.') {
      isDot = 1;
   }
   TBranch* branch1 = 0;
   TRealData* rd = 0;
   TRealData* rdi = 0;
   TIter nexti(cl->GetListOfRealData());
   TIter next(cl->GetListOfRealData());
   // Note: This loop results in a full split because the
   //       real data list includes all data members of
   //       data members.
   while ((rd = (TRealData*) next())) {
      if (rd->TestBit(TRealData::kTransient)) continue;

      // Loop over all data members creating branches for each one.
      TDataMember* dm = rd->GetDataMember();
      if (!dm->IsPersistent()) {
         // Do not process members with an "!" as the first character in the comment field.
         continue;
      }
      if (rd->IsObject()) {
         // We skip data members of class type.
         // But we do build their real data, their
         // streamer info, and write their streamer
         // info to the current directory's file.
         // Oh yes, and we also do this for all of
         // their base classes.
         TClass* clm = TClass::GetClass(dm->GetFullTypeName());
         if (clm) {
            BuildStreamerInfo(clm, (char*) obj + rd->GetThisOffset());
         }
         continue;
      }
      rdname = rd->GetName();
      dname = dm->GetName();
      if (cl->CanIgnoreTObjectStreamer()) {
         // Skip the TObject base class data members.
         // FIXME: This prevents a user from ever
         //        using these names themself!
         if (!strcmp(dname, "fBits")) {
            continue;
         }
         if (!strcmp(dname, "fUniqueID")) {
            continue;
         }
      }
      TDataType* dtype = dm->GetDataType();
      Int_t code = 0;
      if (dtype) {
         code = dm->GetDataType()->GetType();
      }
      // Encode branch name. Use real data member name
      branchname = rdname;
      if (isDot) {
         if (dm->IsaPointer()) {
            // FIXME: This is wrong!  The asterisk is not usually in the front!
            branchname.Form("%s%s", name, &rdname[1]);
         } else {
            branchname.Form("%s%s", name, &rdname[0]);
         }
      }
      // FIXME: Change this to a string stream.
      TString leaflist;
      Int_t offset = rd->GetThisOffset();
      char* pointer = ((char*) obj) + offset;
      if (dm->IsaPointer()) {
         // We have a pointer to an object or a pointer to an array of basic types.
         TClass* clobj = 0;
         if (!dm->IsBasic()) {
            clobj = TClass::GetClass(dm->GetTypeName());
         }
         if (clobj && clobj->InheritsFrom(TClonesArray::Class())) {
            // We have a pointer to a clones array.
            char* cpointer = (char*) pointer;
            char** ppointer = (char**) cpointer;
            TClonesArray* li = (TClonesArray*) *ppointer;
            if (splitlevel != 2) {
               if (isDot) {
                  branch1 = new TBranchClones(branch,branchname, pointer, bufsize);
               } else {
                  // FIXME: This is wrong!  The asterisk is not usually in the front!
                  branch1 = new TBranchClones(branch,&branchname.Data()[1], pointer, bufsize);
               }
               blist->Add(branch1);
            } else {
               if (isDot) {
                  branch1 = new TBranchObject(branch, branchname, li->ClassName(), pointer, bufsize);
               } else {
                  // FIXME: This is wrong!  The asterisk is not usually in the front!
                  branch1 = new TBranchObject(branch, &branchname.Data()[1], li->ClassName(), pointer, bufsize);
               }
               blist->Add(branch1);
            }
         } else if (clobj) {
            // We have a pointer to an object.
            //
            // It must be a TObject object.
            if (!clobj->IsTObject()) {
               continue;
            }
            branch1 = new TBranchObject(branch, dname, clobj->GetName(), pointer, bufsize, 0);
            if (isDot) {
               branch1->SetName(branchname);
            } else {
               // FIXME: This is wrong!  The asterisk is not usually in the front!
               // Do not use the first character (*).
               branch1->SetName(&branchname.Data()[1]);
            }
            blist->Add(branch1);
         } else {
            // We have a pointer to an array of basic types.
            //
            // Check the comments in the text of the code for an index specification.
            const char* index = dm->GetArrayIndex();
            if (index[0]) {
               // We are a pointer to a varying length array of basic types.
               //check that index is a valid data member name
               //if member is part of an object (e.g. fA and index=fN)
               //index must be changed from fN to fA.fN
               TString aindex (rd->GetName());
               Ssiz_t rdot = aindex.Last('.');
               if (rdot>=0) {
                  aindex.Remove(rdot+1);
                  aindex.Append(index);
               }
               nexti.Reset();
               while ((rdi = (TRealData*) nexti())) {
                  if (rdi->TestBit(TRealData::kTransient)) continue;

                  if (!strcmp(rdi->GetName(), index)) {
                     break;
                  }
                  if (!strcmp(rdi->GetName(), aindex)) {
                     index = rdi->GetName();
                     break;
                  }
               }

               char vcode = DataTypeToChar((EDataType)code);
               // Note that we differentiate between strings and
               // char array by the fact that there is NO specified
               // size for a string (see next if (code == 1)

               if (vcode) {
                  leaflist.Form("%s[%s]/%c", &rdname[0], index, vcode);
               } else {
                  Error("BranchOld", "Cannot create branch for rdname: %s code: %d", branchname.Data(), code);
                  leaflist = "";
               }
            } else {
               // We are possibly a character string.
               if (code == 1) {
                  // We are a character string.
                  leaflist.Form("%s/%s", dname, "C");
               } else {
                  // Invalid array specification.
                  // FIXME: We need an error message here.
                  continue;
               }
            }
            // There are '*' in both the branchname and leaflist, remove them.
            TString bname( branchname );
            bname.ReplaceAll("*","");
            leaflist.ReplaceAll("*","");
            // Add the branch to the tree and indicate that the address
            // is that of a pointer to be dereferenced before using.
            branch1 = new TBranch(branch, bname, *((void**) pointer), leaflist, bufsize);
            TLeaf* leaf = (TLeaf*) branch1->GetListOfLeaves()->At(0);
            leaf->SetBit(TLeaf::kIndirectAddress);
            leaf->SetAddress((void**) pointer);
            blist->Add(branch1);
         }
      } else if (dm->IsBasic()) {
         // We have a basic type.

         char vcode = DataTypeToChar((EDataType)code);
         if (vcode) {
            leaflist.Form("%s/%c", rdname, vcode);
         } else {
            Error("BranchOld", "Cannot create branch for rdname: %s code: %d", branchname.Data(), code);
            leaflist = "";
         }
         branch1 = new TBranch(branch, branchname, pointer, leaflist, bufsize);
         branch1->SetTitle(rdname);
         blist->Add(branch1);
      } else {
         // We have a class type.
         // Note: This cannot happen due to the rd->IsObject() test above.
         // FIXME: Put an error message here just in case.
      }
      if (branch1) {
         branch1->SetOffset(offset);
      } else {
         Warning("BranchOld", "Cannot process member: '%s'", rdname);
      }
   }
   if (delobj) {
      delete obj;
      obj = 0;
   }
   return branch;
}

//______________________________________________________________________________
TBranch* TTree::BranchRef()
{
   // Build the optional branch supporting the TRefTable.
   // This branch will keep all the information to find the branches
   // containing referenced objects.
   //
   // At each Tree::Fill, the branch numbers containing the
   // referenced objects are saved to the TBranchRef basket.
   // When the Tree header is saved (via TTree::Write), the branch
   // is saved keeping the information with the pointers to the branches
   // having referenced objects.

   if (!fBranchRef) {
      fBranchRef = new TBranchRef(this);
   }
   return fBranchRef;
}

//______________________________________________________________________________
TBranch* TTree::Bronch(const char* name, const char* classname, void* addr, Int_t bufsize /* = 32000 */, Int_t splitlevel /* = 99 */)
{
   // Create a new TTree BranchElement.
   //
   //    WARNING about this new function
   //    ===============================
   //
   //    This function is designed to replace the internal
   //    implementation of the old TTree::Branch (whose implementation
   //    has been moved to BranchOld).
   //
   //    NOTE: The 'Bronch' method supports only one possible calls
   //    signature (where the object type has to be specified
   //    explicitly and the address must be the address of a pointer).
   //    For more flexibility use 'Branch'.  Use Bronch only in (rare)
   //    cases (likely to be legacy cases) where both the new and old
   //    implementation of Branch needs to be used at the same time.
   //
   //    This function is far more powerful than the old Branch
   //    function.  It supports the full C++, including STL and has
   //    the same behaviour in split or non-split mode. classname does
   //    not have to derive from TObject.  The function is based on
   //    the new TStreamerInfo.
   //
   //    Build a TBranchElement for an object of class classname.
   //
   //    addr is the address of a pointer to an object of class
   //    classname.  The class dictionary must be available (ClassDef
   //    in class header).
   //
   //    Note: See the comments in TBranchElement::SetAddress() for a more
   //          detailed discussion of the meaning of the addr parameter.
   //
   //    This option requires access to the library where the
   //    corresponding class is defined. Accessing one single data
   //    member in the object implies reading the full object.
   //
   //    By default the branch buffers are stored in the same file as the Tree.
   //    use TBranch::SetFile to specify a different file
   //
   //      IMPORTANT NOTE about branch names
   //    In case two or more master branches contain subbranches with
   //    identical names, one must add a "." (dot) character at the end
   //    of the master branch name. This will force the name of the subbranch
   //    to be master.subbranch instead of simply subbranch.
   //    This situation happens when the top level object (say event)
   //    has two or more members referencing the same class.
   //    For example, if a Tree has two branches B1 and B2 corresponding
   //    to objects of the same class MyClass, one can do:
   //       tree.Branch("B1.","MyClass",&b1,8000,1);
   //       tree.Branch("B2.","MyClass",&b2,8000,1);
   //    if MyClass has 3 members a,b,c, the two instructions above will generate
   //    subbranches called B1.a, B1.b ,B1.c, B2.a, B2.b, B2.c
   //
   //    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.
   //
   //    Use splitlevel < 0 instead of splitlevel=0 when the class
   //    has a custom Streamer
   //
   //    Note: if the split level is set to the default (99),  TTree::Branch will
   //    not issue a warning if the class can not be split.

   return BronchExec(name, classname, addr, kTRUE, bufsize, splitlevel);
}

//______________________________________________________________________________
TBranch* TTree::BronchExec(const char* name, const char* classname, void* addr, Bool_t isptrptr, Int_t bufsize /* = 32000 */, Int_t splitlevel /* = 99 */)
{
   // Helper function implementing TTree::Bronch and TTree::Branch(const char *name, T &obj);

   TClass* cl = TClass::GetClass(classname);
   if (!cl) {
      Error("Bronch", "Cannot find class:%s", classname);
      return 0;
   }

   //if splitlevel <= 0 and class has a custom Streamer, we must create
   //a TBranchObject. We cannot assume that TClass::ReadBuffer is consistent
   //with the custom Streamer. The penalty is that one cannot process
   //this Tree without the class library containing the class.

   char* objptr = 0;
   if (!isptrptr) {
      objptr = (char*)addr;
   } else if (addr) {
      objptr = *((char**) addr);
   }

   if (cl == TClonesArray::Class()) {
      TClonesArray* clones = (TClonesArray*) objptr;
      if (!clones) {
         Error("Bronch", "Pointer to TClonesArray is null");
         return 0;
      }
      if (!clones->GetClass()) {
         Error("Bronch", "TClonesArray with no class defined in branch: %s", name);
         return 0;
      }
      if (!clones->GetClass()->HasDataMemberInfo()) {
         Error("Bronch", "TClonesArray with no dictionary defined in branch: %s", name);
         return 0;
      }
      bool hasCustomStreamer = clones->GetClass()->TestBit(TClass::kHasCustomStreamerMember);
      if (splitlevel > 0) {
         if (hasCustomStreamer)
            Warning("Bronch", "Using split mode on a class: %s with a custom Streamer", clones->GetClass()->GetName());
      } else {
         if (hasCustomStreamer) clones->BypassStreamer(kFALSE);
         TBranchObject *branch = new TBranchObject(this,name,classname,addr,bufsize,0,/*compress=*/ -1,isptrptr);
         fBranches.Add(branch);
         return branch;
      }
   }

   if (cl->GetCollectionProxy()) {
      TVirtualCollectionProxy* collProxy = cl->GetCollectionProxy();
      //if (!collProxy) {
      //   Error("Bronch", "%s is missing its CollectionProxy (for branch %s)", classname, name);
      //}
      TClass* inklass = collProxy->GetValueClass();
      if (!inklass && (collProxy->GetType() == 0)) {
         Error("Bronch", "%s with no class defined in branch: %s", classname, name);
         return 0;
      }
      if ((splitlevel > 0) && inklass && (inklass->GetCollectionProxy() == 0)) {
         ROOT::ESTLType stl = cl->GetCollectionType();
         if ((stl != ROOT::kSTLmap) && (stl != ROOT::kSTLmultimap)) {
            if (!inklass->HasDataMemberInfo()) {
               Error("Bronch", "Container with no dictionary defined in branch: %s", name);
               return 0;
            }
            if (inklass->TestBit(TClass::kHasCustomStreamerMember)) {
               Warning("Bronch", "Using split mode on a class: %s with a custom Streamer", inklass->GetName());
            }
         }
      }
      //-------------------------------------------------------------------------
      // If the splitting switch is enabled, the split level is big enough and
      // the collection contains pointers we can split it
      //-------------------------------------------------------------------------
      TBranch *branch;
      if( splitlevel > kSplitCollectionOfPointers && collProxy->HasPointers() )
         branch = new TBranchSTL( this, name, collProxy, bufsize, splitlevel );
      else
         branch = new TBranchElement(this, name, collProxy, bufsize, splitlevel);
      fBranches.Add(branch);
      if (isptrptr) {
         branch->SetAddress(addr);
      } else {
         branch->SetObject(addr);
      }
      return branch;
   }

   Bool_t hasCustomStreamer = kFALSE;
   if (!cl->HasDataMemberInfo() && !cl->GetCollectionProxy()) {
      Error("Bronch", "Cannot find dictionary for class: %s", classname);
      return 0;
   }

   if (!cl->GetCollectionProxy() && cl->TestBit(TClass::kHasCustomStreamerMember)) {
      // Not an STL container and the linkdef file had a "-" after the class name.
      hasCustomStreamer = kTRUE;
   }

   if (splitlevel < 0 || ((splitlevel == 0) && hasCustomStreamer && cl->IsTObject())) {
      TBranchObject* branch = new TBranchObject(this, name, classname, addr, bufsize, 0, /*compress=*/ -1, isptrptr);
      fBranches.Add(branch);
      return branch;
   }

   if (cl == TClonesArray::Class()) {
      // Special case of TClonesArray.
      // No dummy object is created.
      // The streamer info is not rebuilt unoptimized.
      // No dummy top-level branch is created.
      // No splitting is attempted.
      TBranchElement* branch = new TBranchElement(this, name, (TClonesArray*) objptr, bufsize, splitlevel%kSplitCollectionOfPointers);
      fBranches.Add(branch);
      if (isptrptr) {
         branch->SetAddress(addr);
      } else {
         branch->SetObject(addr);
      }
      return branch;
   }

   //
   // If we are not given an object to use as an i/o buffer
   // then create a temporary one which we will delete just
   // before returning.
   //

   Bool_t delobj = kFALSE;

   if (!objptr) {
      objptr = (char*) cl->New();
      delobj = kTRUE;
   }

   //
   // Avoid splitting unsplittable classes.
   //

   if ((splitlevel > 0) && !cl->CanSplit()) {
      if (splitlevel != 99) {
         Warning("Bronch", "%s cannot be split, resetting splitlevel to 0", cl->GetName());
      }
      splitlevel = 0;
   }

   //
   // Make sure the streamer info is built and fetch it.
   //
   // If we are splitting, then make sure the streamer info
   // is built unoptimized (data members are not combined).
   //

   TStreamerInfo* sinfo = BuildStreamerInfo(cl, objptr, splitlevel==0);
   if (!sinfo) {
      Error("Bronch", "Cannot build the StreamerInfo for class: %s", cl->GetName());
      return 0;
   }

   //
   // Do we have a final dot in our name?
   //

   // Note: The branch constructor which takes a folder as input
   //       creates top-level branch names with dots in them to
   //       indicate the folder hierarchy.
   char* dot = (char*) strchr(name, '.');
   Int_t nch = strlen(name);
   Bool_t dotlast = kFALSE;
   if (nch && (name[nch-1] == '.')) {
      dotlast = kTRUE;
   }

   //
   // Create a dummy top level branch object.
   //

   Int_t id = -1;
   if (splitlevel > 0) {
      id = -2;
   }
   TBranchElement* branch = new TBranchElement(this, name, sinfo, id, objptr, bufsize, splitlevel);
   fBranches.Add(branch);

   //
   // Do splitting, if requested.
   //

   if (splitlevel%kSplitCollectionOfPointers > 0) {
      // Loop on all public data members of the class and its base classes and create branches for each one.
      TObjArray* blist = branch->GetListOfBranches();
      TIter next(sinfo->GetElements());
      TStreamerElement* element = 0;
      TString bname;
      for (id = 0; (element = (TStreamerElement*) next()); ++id) {
         if (element->IsA() == TStreamerArtificial::Class()) {
            continue;
         }
         if (element->TestBit(TStreamerElement::kRepeat)) {
            continue;
         }
         if (element->TestBit(TStreamerElement::kCache) && !element->TestBit(TStreamerElement::kWrite)) {
            continue;
         }
         char* pointer = (char*) (objptr + element->GetOffset());
         // FIXME: This is not good enough, an STL container can be
         //        a base, and the test will fail.
         //        See TBranchElement::InitializeOffsets() for the
         //        correct test.
         Bool_t isBase = (element->IsA() == TStreamerBase::Class());
         if (isBase) {
            TClass* clbase = element->GetClassPointer();
            if ((clbase == TObject::Class()) && cl->CanIgnoreTObjectStreamer()) {
               // Note: TStreamerInfo::Compile() leaves this element
               //       out of the optimized info, although it does
               //       exists in the non-compiled  and non-optimized info.
               // FIXME: The test that TStreamerInfo::Compile() uses
               //        is element->GetType() < 0, so that is what
               //        we should do as well.
               continue;
            }
            if (clbase->GetListOfRealData()->GetSize() == 0) {
               // Do not create a branch for empty bases.
               continue;
            }
         }
         if (dot) {
            if (dotlast) {
               bname.Form("%s%s", name, element->GetFullName());
            } else {
               // FIXME: We are in the case where we have a top-level
               //        branch name that was created by the branch
               //        constructor which takes a folder as input.
               //        The internal dots in the name are in place of
               //        of the original slashes and represent the
               //        folder hierarchy.
               if (isBase) {
                  // FIXME: This is very strange, this is the only case where
                  //        we create a branch for a base class that does
                  //        not have the base class name in the branch name.
                  // FIXME: This is also quite bad since classes with two
                  //        or more base classes end up with sub-branches
                  //        that have the same name.
                  bname = name;
               } else {
                  bname.Form("%s.%s", name, element->GetFullName());
               }
            }
         } else {
            // Note: For a base class element, this results in the branchname
            //       being the name of the base class.
            bname.Form("%s", element->GetFullName());
         }

         if( splitlevel > kSplitCollectionOfPointers && element->GetClass() &&
             element->GetClass()->GetCollectionProxy() &&
             element->GetClass()->GetCollectionProxy()->HasPointers() )
         {
            TBranchSTL* brSTL = new TBranchSTL( branch, bname, element->GetClass()->GetCollectionProxy(), bufsize, splitlevel-1, sinfo, id );
            blist->Add(brSTL);
         }
         else
         {
            TBranchElement* bre = new TBranchElement(branch, bname, sinfo, id, pointer, bufsize, splitlevel - 1);
            bre->SetParentClass(cl);
            blist->Add(bre);
         }
      }
   }

   //
   // Setup our offsets into the user's i/o buffer.
   //

   if (isptrptr) {
      branch->SetAddress(addr);
   } else {
      branch->SetObject(addr);
   }

   if (delobj) {
      cl->Destructor(objptr);
      objptr = 0;
   }

   return branch;
}

//______________________________________________________________________________
void TTree::Browse(TBrowser* b)
{
   // Browse content of the TTree.

   fBranches.Browse(b);
   if (fUserInfo) {
      if (strcmp("TList",fUserInfo->GetName())==0) {
         fUserInfo->SetName("UserInfo");
         b->Add(fUserInfo);
         fUserInfo->SetName("TList");
      } else {
         b->Add(fUserInfo);
      }
   }
}

//______________________________________________________________________________
Int_t TTree::BuildIndex(const char* majorname, const char* minorname /* = "0" */)
{
   // Build a Tree Index (default is TTreeIndex).
   // See a description of the parameters and functionality in
   // TTreeIndex::TTreeIndex().
   //
   // The return value is the number of entries in the Index (< 0 indicates failure).
   //
   // A TTreeIndex object pointed by fTreeIndex is created.
   // This object will be automatically deleted by the TTree destructor.
   // See also comments in TTree::SetTreeIndex().

   fTreeIndex = GetPlayer()->BuildIndex(this, majorname, minorname);
   if (fTreeIndex->IsZombie()) {
      delete fTreeIndex;
      fTreeIndex = 0;
      return 0;
   }
   return fTreeIndex->GetN();
}

//______________________________________________________________________________
TStreamerInfo* TTree::BuildStreamerInfo(TClass* cl, void* pointer /* = 0 */, Bool_t canOptimize /* = kTRUE */ )
{
   // Build StreamerInfo for class cl.
   // pointer is an optional argument that may contain a pointer to an object of cl.

   if (!cl) {
      return 0;
   }
   cl->BuildRealData(pointer);
   TStreamerInfo* sinfo = (TStreamerInfo*)cl->GetStreamerInfo(cl->GetClassVersion());

   // Create StreamerInfo for all base classes.
   TBaseClass* base = 0;
   TIter nextb(cl->GetListOfBases());
   while((base = (TBaseClass*) nextb())) {
      if (base->IsSTLContainer()) {
         continue;
      }
      TClass* clm = TClass::GetClass(base->GetName());
      BuildStreamerInfo(clm, pointer, canOptimize);
   }
   if (sinfo && fDirectory) {
      sinfo->ForceWriteInfo(fDirectory->GetFile());
   }
   return sinfo;
}

//______________________________________________________________________________
TFile* TTree::ChangeFile(TFile* file)
{
   // Called by TTree::Fill() when file has reached its maximum fgMaxTreeSize.
   // Create a new file. If the original file is named "myfile.root",
   // subsequent files are named "myfile_1.root", "myfile_2.root", etc.
   //
   // Returns a pointer to the new file.
   //
   // Currently, the automatic change of file is restricted
   // to the case where the tree is in the top level directory.
   // The file should not contain sub-directories.
   //
   // Before switching to a new file, the tree header is written
   // to the current file, then the current file is closed.
   //
   // To process the multiple files created by ChangeFile, one must use
   // a TChain.
   //
   // The new file name has a suffix "_N" where N is equal to fFileNumber+1.
   // By default a Root session starts with fFileNumber=0. One can set
   // fFileNumber to a different value via TTree::SetFileNumber.
   // In case a file named "_N" already exists, the function will try
   // a file named "__N", then "___N", etc.
   //
   // fgMaxTreeSize can be set via the static function TTree::SetMaxTreeSize.
   // The default value of fgMaxTreeSize is 100 Gigabytes.
   //
   // If the current file contains other objects like TH1 and TTree,
   // these objects are automatically moved to the new file.
   //
   // IMPORTANT NOTE:
   // Be careful when writing the final Tree header to the file!
   // Don't do:
   //  TFile *file = new TFile("myfile.root","recreate");
   //  TTree *T = new TTree("T","title");
   //  T->Fill(); //loop
   //  file->Write();
   //  file->Close();
   // but do the following:
   //  TFile *file = new TFile("myfile.root","recreate");
   //  TTree *T = new TTree("T","title");
   //  T->Fill(); //loop
   //  file = T->GetCurrentFile(); //to get the pointer to the current file
   //  file->Write();
   //  file->Close();

   file->cd();
   Write();
   Reset();
   char* fname = new char[2000];
   ++fFileNumber;
   char uscore[10];
   for (Int_t i = 0; i < 10; ++i) {
      uscore[i] = 0;
   }
   Int_t nus = 0;
   // Try to find a suitable file name that does not already exist.
   while (nus < 10) {
      uscore[nus] = '_';
      fname[0] = 0;
      strlcpy(fname, file->GetName(),2000);

      if (fFileNumber > 1) {
         char* cunder = strrchr(fname, '_');
         if (cunder) {
            snprintf(cunder,2000-Int_t(cunder-fname), "%s%d", uscore, fFileNumber);
            const char* cdot = strrchr(file->GetName(), '.');
            if (cdot) {
               strlcat(fname, cdot,2000);
            }
         } else {
            char fcount[10];
            snprintf(fcount,10, "%s%d", uscore, fFileNumber);
            strlcat(fname, fcount,2000);
         }
      } else {
         char* cdot = strrchr(fname, '.');
         if (cdot) {
            snprintf(cdot,2000-Int_t(fname-cdot), "%s%d", uscore, fFileNumber);
            strlcat(fname, strrchr(file->GetName(), '.'),2000);
         } else {
            char fcount[10];
            snprintf(fcount,10, "%s%d", uscore, fFileNumber);
            strlcat(fname, fcount,2000);
         }
      }
      if (gSystem->AccessPathName(fname)) {
         break;
      }
      ++nus;
      Warning("ChangeFile", "file %s already exist, trying with %d underscores", fname, nus+1);
   }
   Int_t compress = file->GetCompressionSettings();
   TFile* newfile = TFile::Open(fname, "recreate", "chain files", compress);
   if (newfile == 0) {
      Error("Fill","Failed to open new file %s, continuing as a memory tree.",fname);
   } else {
      Printf("Fill: Switching to new file: %s", fname);
   }
   // The current directory may contain histograms and trees.
   // These objects must be moved to the new file.
   TBranch* branch = 0;
   TObject* obj = 0;
   while ((obj = file->GetList()->First())) {
      file->Remove(obj);
      // Histogram: just change the directory.
      if (obj->InheritsFrom("TH1")) {
         gROOT->ProcessLine(TString::Format("((%s*)0x%lx)->SetDirectory((TDirectory*)0x%lx);", obj->ClassName(), (Long_t) obj, (Long_t) newfile));
         continue;
      }
      // Tree: must save all trees in the old file, reset them.
      if (obj->InheritsFrom(TTree::Class())) {
         TTree* t = (TTree*) obj;
         if (t != this) {
            t->AutoSave();
            t->Reset();
            t->fFileNumber = fFileNumber;
         }
         t->SetDirectory(newfile);
         TIter nextb(t->GetListOfBranches());
         while ((branch = (TBranch*)nextb())) {
            branch->SetFile(newfile);
         }
         if (t->GetBranchRef()) {
            t->GetBranchRef()->SetFile(newfile);
         }
         continue;
      }
      // Not a TH1 or a TTree, move object to new file.
      if (newfile) newfile->Append(obj);
      file->Remove(obj);
   }
   delete file;
   file = 0;
   delete[] fname;
   fname = 0;
   return newfile;
}

//______________________________________________________________________________
Int_t TTree::CheckBranchAddressType(TBranch* branch, TClass* ptrClass, EDataType datatype, Bool_t isptr)
{
   // Check whether or not the address described by the last 3 parameters
   // matches the content of the branch. If a Data Model Evolution conversion
   // is involved, reset the fInfo of the branch.
   // The return values are:
   //  kMissingBranch (-5) : Missing branch
   //  kInternalError (-4) : Internal error (could not find the type corresponding to a data type number)
   //  kMissingCompiledCollectionProxy (-3) : Missing compiled collection proxy for a compiled collection
   //  kMismatch (-2) : Non-Class Pointer type given does not match the type expected by the branch
   //  kClassMismatch (-1) : Class Pointer type given does not match the type expected by the branch
   //  kMatch (0) : perfect match
   //  kMatchConversion (1) : match with (I/O) conversion
   //  kMatchConversionCollection (2) : match with (I/O) conversion of the content of a collection
   //  kMakeClass (3) : MakeClass mode so we can not check.
   //  kVoidPtr (4) : void* passed so no check was made.
   //  kNoCheck (5) : Underlying TBranch not yet available so no check was made.

   if (GetMakeClass()) {
      // If we are in MakeClass mode so we do not really use classes.
      return kMakeClass;
   }

   // Let's determine what we need!
   TClass* expectedClass = 0;
   EDataType expectedType = kOther_t;
   if (0 != branch->GetExpectedType(expectedClass,expectedType) ) {
      // Something went wrong, the warning message has already be issued.
      return kInternalError;
   }
   if (expectedClass && datatype == kOther_t && ptrClass == 0) {
      if (branch->InheritsFrom( TBranchElement::Class() )) {
         TBranchElement* bEl = (TBranchElement*)branch;
         bEl->SetTargetClass( expectedClass->GetName() );
      }
      if (expectedClass && expectedClass->GetCollectionProxy() && dynamic_cast<TEmulatedCollectionProxy*>(expectedClass->GetCollectionProxy())) {
         Error("SetBranchAddress", "Unable to determine the type given for the address for \"%s\". "
               "The class expected (%s) refers to an stl collection and do not have a compiled CollectionProxy.  "
               "Please generate the dictionary for this class (%s)",
               branch->GetName(), expectedClass->GetName(), expectedClass->GetName());
         return kMissingCompiledCollectionProxy;
      }
      if (!expectedClass->IsLoaded()) {
         // The originally expected class does not have a dictionary, it is then plausible that the pointer being passed is the right type
         // (we really don't know).  So let's express that.
         Error("SetBranchAddress", "Unable to determine the type given for the address for \"%s\". "
               "The class expected (%s) does not have a dictionary and needs to be emulated for I/O purposes but is being passed a compiled object."
               "Please generate the dictionary for this class (%s)",
               branch->GetName(), expectedClass->GetName(), expectedClass->GetName());
      } else {
         Error("SetBranchAddress", "Unable to determine the type given for the address for \"%s\". "
               "This is probably due to a missing dictionary, the original data class for this branch is %s.", branch->GetName(), expectedClass->GetName());
      }
      return kClassMismatch;
   }
   if (expectedClass && ptrClass && (branch->GetMother() == branch)) {
      // Top Level branch
      if (!isptr) {
         Error("SetBranchAddress", "The address for \"%s\" should be the address of a pointer!", branch->GetName());
      }
   }
   if (expectedType == kFloat16_t) {
      expectedType = kFloat_t;
   }
   if (expectedType == kDouble32_t) {
      expectedType = kDouble_t;
   }
   if (datatype == kFloat16_t) {
      datatype = kFloat_t;
   }
   if (datatype == kDouble32_t) {
      datatype = kDouble_t;
   }

   //---------------------------------------------------------------------------
   // Deal with the class renaming
   //---------------------------------------------------------------------------
   if( expectedClass && ptrClass &&
       expectedClass != ptrClass &&
       branch->InheritsFrom( TBranchElement::Class() ) &&
       ptrClass->GetSchemaRules() &&
       ptrClass->GetSchemaRules()->HasRuleWithSourceClass( expectedClass->GetName() ) ) {

      TBranchElement* bEl = (TBranchElement*)branch;

      if ( ptrClass->GetCollectionProxy() && expectedClass->GetCollectionProxy() ) {
         if (gDebug > 7)
            Info("SetBranchAddress", "Matching STL colleciton (at least according to the SchemaRuleSet when "
               "reading a %s into a %s",expectedClass->GetName(),ptrClass->GetName());

         bEl->SetTargetClass( ptrClass->GetName() );
         return kMatchConversion;

      } else if ( !ptrClass->GetConversionStreamerInfo( expectedClass, bEl->GetClassVersion() ) &&
          !ptrClass->FindConversionStreamerInfo( expectedClass, bEl->GetCheckSum() ) ) {
         Error("SetBranchAddress", "The pointer type given \"%s\" does not correspond to the type needed \"%s\" by the branch: %s", ptrClass->GetName(), bEl->GetClassName(), branch->GetName());

         bEl->SetTargetClass( expectedClass->GetName() );
         return kClassMismatch;
      }
      else {

         bEl->SetTargetClass( ptrClass->GetName() );
         return kMatchConversion;
      }

   } else if (expectedClass && ptrClass && !expectedClass->InheritsFrom(ptrClass)) {

      if (expectedClass->GetCollectionProxy() && ptrClass->GetCollectionProxy() &&
          branch->InheritsFrom( TBranchElement::Class() ) &&
          expectedClass->GetCollectionProxy()->GetValueClass() &&
          ptrClass->GetCollectionProxy()->GetValueClass() )
      {
         // In case of collection, we know how to convert them, if we know how to convert their content.
         // NOTE: we need to extend this to std::pair ...

         TClass *onfileValueClass = expectedClass->GetCollectionProxy()->GetValueClass();
         TClass *inmemValueClass = ptrClass->GetCollectionProxy()->GetValueClass();

         if (inmemValueClass->GetSchemaRules() &&
             inmemValueClass->GetSchemaRules()->HasRuleWithSourceClass(onfileValueClass->GetName() ) )
         {
            TBranchElement* bEl = (TBranchElement*)branch;
            bEl->SetTargetClass( ptrClass->GetName() );
            return kMatchConversionCollection;
         }
      }

      Error("SetBranchAddress", "The pointer type given (%s) does not correspond to the class needed (%s) by the branch: %s", ptrClass->GetName(), expectedClass->GetName(), branch->GetName());
      if (branch->InheritsFrom( TBranchElement::Class() )) {
         TBranchElement* bEl = (TBranchElement*)branch;
         bEl->SetTargetClass( expectedClass->GetName() );
      }
      return kClassMismatch;

   } else if ((expectedType != kOther_t) && (datatype != kOther_t) && (expectedType != kNoType_t) && (datatype != kNoType_t) && (expectedType != datatype)) {
      if (datatype != kChar_t) {
         // For backward compatibility we assume that (char*) was just a cast and/or a generic address
         Error("SetBranchAddress", "The pointer type given \"%s\" (%d) does not correspond to the type needed \"%s\" (%d) by the branch: %s",
               TDataType::GetTypeName(datatype), datatype, TDataType::GetTypeName(expectedType), expectedType, branch->GetName());
         return kMismatch;
      }
   } else if ((expectedClass && (datatype != kOther_t && datatype != kNoType_t && datatype != kInt_t)) ||
              (ptrClass && (expectedType != kOther_t && expectedType != kNoType_t && datatype != kInt_t)) ) {
      // Sometime a null pointer can look an int, avoid complaining in that case.
      if (expectedClass) {
         Error("SetBranchAddress", "The pointer type given \"%s\" (%d) does not correspond to the type needed \"%s\" by the branch: %s",
               TDataType::GetTypeName(datatype), datatype, expectedClass->GetName(), branch->GetName());
         if (branch->InheritsFrom( TBranchElement::Class() )) {
            TBranchElement* bEl = (TBranchElement*)branch;
            bEl->SetTargetClass( expectedClass->GetName() );
         }
      } else {
         // In this case, it is okay if the first data member is of the right type (to support the case where we are being passed
         // a struct).
         bool good = false;
         if (ptrClass->IsLoaded()) {
            TIter next(ptrClass->GetListOfRealData());
            TRealData *rdm;
            while ((rdm = (TRealData*)next())) {
               if (rdm->GetThisOffset() == 0) {
                  break;
               }
            }
         } else {
            TIter next(ptrClass->GetListOfDataMembers());
            TDataMember *dm;
            while ((dm = (TDataMember*)next())) {
               if (dm->GetOffset() == 0) {
                  TDataType *dmtype = dm->GetDataType();
                  if (dmtype) {
                     EDataType etype = (EDataType)dmtype->GetType();
                     good = (etype == expectedType);
                  }
                  break;
               }
            }
         }
         if (!good) {
            Error("SetBranchAddress", "The pointer type given \"%s\" does not correspond to the type needed \"%s\" (%d) by the branch: %s",
                  ptrClass->GetName(), TDataType::GetTypeName(expectedType), expectedType, branch->GetName());
         }
      }
      return kMismatch;
   }
   if (expectedClass && expectedClass->GetCollectionProxy() && dynamic_cast<TEmulatedCollectionProxy*>(expectedClass->GetCollectionProxy())) {
      Error("SetBranchAddress", writeStlWithoutProxyMsg,
            expectedClass->GetName(), branch->GetName(), expectedClass->GetName());
      if (branch->InheritsFrom( TBranchElement::Class() )) {
         TBranchElement* bEl = (TBranchElement*)branch;
         bEl->SetTargetClass( expectedClass->GetName() );
      }
      return kMissingCompiledCollectionProxy;
   }
   if (expectedClass && branch->InheritsFrom( TBranchElement::Class() )) {
      TBranchElement* bEl = (TBranchElement*)branch;
      bEl->SetTargetClass( expectedClass->GetName() );
   }
   return kMatch;
}

//______________________________________________________________________________
TTree* TTree::CloneTree(Long64_t nentries /* = -1 */, Option_t* option /* = "" */)
{
   // Create a clone of this tree and copy nentries.
   //
   // By default copy all entries.
   // The compression level of the cloned tree is set to the destination
   // file's compression level.
   //
   // NOTE: Only active branches are copied.
   // NOTE: If the TTree is a TChain, the structure of the first TTree
   //       is used for the copy.
   //
   // IMPORTANT: The cloned tree stays connected with this tree until
   //            this tree is deleted. In particular, any changes in
   //            branch addresses in this tree are forwarded to the
   //            clone trees, unless a branch in a clone tree has had
   //            its address changed, in which case that change stays in
   //            effect. When this tree is deleted, all the addresses of
   //            the cloned tree are reset to their default values.
   //
   // If 'option' contains the word 'fast' and nentries is -1, the
   // cloning will be done without unzipping or unstreaming the baskets
   // (i.e., a direct copy of the raw bytes on disk).
   //
   // When 'fast' is specified, 'option' can also contain a sorting
   // order for the baskets in the output file.
   //
   // There are currently 3 supported sorting order:
   //    SortBasketsByOffset (the default)
   //    SortBasketsByBranch
   //    SortBasketsByEntry
   //
   // When using SortBasketsByOffset the baskets are written in the
   // output file in the same order as in the original file (i.e. the
   // baskets are sorted by their offset in the original file; Usually
   // this also means that the baskets are sorted by the index/number of
   // the _last_ entry they contain)
   //
   // When using SortBasketsByBranch all the baskets of each individual
   // branches are stored contiguously. This tends to optimize reading
   // speed when reading a small number (1->5) of branches, since all
   // their baskets will be clustered together instead of being spread
   // across the file. However it might decrease the performance when
   // reading more branches (or the full entry).
   //
   // When using SortBasketsByEntry the baskets with the lowest starting
   // entry are written first. (i.e. the baskets are sorted by the
   // index/number of the first entry they contain). This means that on
   // the file the baskets will be in the order in which they will be
   // needed when reading the whole tree sequentially.
   //
   // For examples of CloneTree, see tutorials:
   //
   //  -- copytree
   //
   //     A macro to copy a subset of a TTree to a new TTree.
   //
   //     The input file has been generated by the program in
   //     $ROOTSYS/test/Event with: Event 1000 1 1 1
   //
   //  -- copytree2
   //
   //     A macro to copy a subset of a TTree to a new TTree.
   //
   //     One branch of the new Tree is written to a separate file.
   //
   //     The input file has been generated by the program in
   //     $ROOTSYS/test/Event with: Event 1000 1 1 1
   //

   // Options
   Bool_t fastClone = kFALSE;

   TString opt = option;
   opt.ToLower();
   if (opt.Contains("fast")) {
      fastClone = kTRUE;
   }

   // If we are a chain, switch to the first tree.
   if ((fEntries > 0) && (LoadTree(0) < 0)) {
         // FIXME: We need an error message here.
         return 0;
   }

   // Note: For a tree we get the this pointer, for
   //       a chain we get the chain's current tree.
   TTree* thistree = GetTree();

   // Note: For a chain, the returned clone will be
   //       a clone of the chain's first tree.
   TTree* newtree = (TTree*) thistree->Clone();
   if (!newtree) {
      return 0;
   }

   // The clone should not delete any objects allocated by SetAddress().
   TObjArray* branches = newtree->GetListOfBranches();
   Int_t nb = branches->GetEntriesFast();
   for (Int_t i = 0; i < nb; ++i) {
      TBranch* br = (TBranch*) branches->UncheckedAt(i);
      if (br->InheritsFrom(TBranchElement::Class())) {
         ((TBranchElement*) br)->ResetDeleteObject();
      }
   }

   // Add the new tree to the list of clones so that
   // we can later inform it of changes to branch addresses.
   thistree->AddClone(newtree);
   if (thistree != this) {
      // In case this object is a TChain, add the clone
      // also to the TChain's list of clones.
      AddClone(newtree);
   }

   newtree->Reset();

   TDirectory* ndir = newtree->GetDirectory();
   TFile* nfile = 0;
   if (ndir) {
      nfile = ndir->GetFile();
   }
   Int_t newcomp = -1;
   if (nfile) {
      newcomp = nfile->GetCompressionSettings();
   }

   //
   // Delete non-active branches from the clone.
   //
   // Note: If we are a chain, this does nothing
   //       since chains have no leaves.
   TObjArray* leaves = newtree->GetListOfLeaves();
   Int_t nleaves = leaves->GetEntriesFast();
   for (Int_t lndx = 0; lndx < nleaves; ++lndx) {
      TLeaf* leaf = (TLeaf*) leaves->UncheckedAt(lndx);
      if (!leaf) {
         continue;
      }
      TBranch* branch = leaf->GetBranch();
      if (branch && (newcomp > -1)) {
         branch->SetCompressionSettings(newcomp);
      }
      if (!branch || !branch->TestBit(kDoNotProcess)) {
         continue;
      }
//      TObjArray* branches = newtree->GetListOfBranches();
//      Int_t nb = branches->GetEntriesFast();
      for (Long64_t i = 0; i < nb; ++i) {
         TBranch* br = (TBranch*) branches->UncheckedAt(i);
         if (br == branch) {
            branches->RemoveAt(i);
            delete br;
            br = 0;
            branches->Compress();
            break;
         }
         TObjArray* lb = br->GetListOfBranches();
         Int_t nb1 = lb->GetEntriesFast();
         for (Int_t j = 0; j < nb1; ++j) {
            TBranch* b1 = (TBranch*) lb->UncheckedAt(j);
            if (!b1) {
               continue;
            }
            if (b1 == branch) {
               lb->RemoveAt(j);
               delete b1;
               b1 = 0;
               lb->Compress();
               break;
            }
            TObjArray* lb1 = b1->GetListOfBranches();
            Int_t nb2 = lb1->GetEntriesFast();
            for (Int_t k = 0; k < nb2; ++k) {
               TBranch* b2 = (TBranch*) lb1->UncheckedAt(k);
               if (!b2) {
                  continue;
               }
               if (b2 == branch) {
                  lb1->RemoveAt(k);
                  delete b2;
                  b2 = 0;
                  lb1->Compress();
                  break;
               }
            }
         }
      }
   }
   leaves->Compress();

   // Copy MakeClass status.
   newtree->SetMakeClass(fMakeClass);

   // Copy branch addresses.
   CopyAddresses(newtree);

   //
   // Copy entries if requested.
   //

   if (nentries != 0) {
      if (fastClone && (nentries < 0)) {
         if ( newtree->CopyEntries( this, -1, option ) < 0 ) {
            // There was a problem!
            Error("CloneTTree", "TTree has not been cloned\n");
            delete newtree;
            newtree = 0;
            return 0;
         }
      } else {
         newtree->CopyEntries( this, nentries, option );
      }
   }

   return newtree;
}

//______________________________________________________________________________
void TTree::CopyAddresses(TTree* tree, Bool_t undo)
{
   // Set branch addresses of passed tree equal to ours.
   // If undo is true, reset the branch address instead of copying them.
   //    This insures 'separation' of a cloned tree from its original

   // Copy branch addresses starting from branches.
   TObjArray* branches = GetListOfBranches();
   Int_t nbranches = branches->GetEntriesFast();
   for (Int_t i = 0; i < nbranches; ++i) {
      TBranch* branch = (TBranch*) branches->UncheckedAt(i);
      if (branch->TestBit(kDoNotProcess)) {
         continue;
      }
      if (undo) {
         TBranch* br = tree->GetBranch(branch->GetName());
         tree->ResetBranchAddress(br);
      } else {
         char* addr = branch->GetAddress();
         if (!addr) {
            if (branch->IsA() == TBranch::Class()) {
               // If the branch was created using a leaflist, the branch itself may not have
               // an address but the leaf might already.
               TLeaf *firstleaf = (TLeaf*)branch->GetListOfLeaves()->At(0);
               if (!firstleaf || firstleaf->GetValuePointer()) {
                  // Either there is no leaf (and thus no point in copying the address)
                  // or the leaf has an address but we can not copy it via the branche
                  // this will be copied via the next loop (over the leaf).
                  continue;
               }
            }
            // Note: This may cause an object to be allocated.
            branch->SetAddress(0);
            addr = branch->GetAddress();
         }
         // FIXME: The GetBranch() function is braindead and may
         //        not find the branch!
         TBranch* br = tree->GetBranch(branch->GetName());
         if (br) {
            br->SetAddress(addr);
            // The copy does not own any object allocated by SetAddress().
            if (br->InheritsFrom(TBranchElement::Class())) {
               ((TBranchElement*) br)->ResetDeleteObject();
            }
         } else {
            Warning("CopyAddresses", "Could not find branch named '%s' in tree named '%s'", branch->GetName(), tree->GetName());
         }
      }
   }

   // Copy branch addresses starting from leaves.
   TObjArray* tleaves = tree->GetListOfLeaves();
   Int_t ntleaves = tleaves->GetEntriesFast();
   for (Int_t i = 0; i < ntleaves; ++i) {
      TLeaf* tleaf = (TLeaf*) tleaves->UncheckedAt(i);
      TBranch* tbranch = tleaf->GetBranch();
      TBranch* branch = GetBranch(tbranch->GetName());
      if (!branch) {
         continue;
      }
      TLeaf* leaf = branch->GetLeaf(tleaf->GetName());
      if (!leaf) {
         continue;
      }
      if (branch->TestBit(kDoNotProcess)) {
         continue;
      }
      if (undo) {
         // Now we know whether the address has been transfered
         tree->ResetBranchAddress(tbranch);
      } else {
         if (!branch->GetAddress() && !leaf->GetValuePointer()) {
            // We should attempts to set the address of the branch.
            // something like:
            //(TBranchElement*)branch->GetMother()->SetAddress(0)
            //plus a few more subtilities (see TBranchElement::GetEntry).
            //but for now we go the simplest route:
            //
            // Note: This may result in the allocation of an object.
            branch->SetupAddresses();
         }
         if (branch->GetAddress()) {
            tree->SetBranchAddress(branch->GetName(), (void*) branch->GetAddress());
            TBranch* br = tree->GetBranch(branch->GetName());
            if (br) {
               // The copy does not own any object allocated by SetAddress().
               // FIXME: We do too much here, br may not be a top-level branch.
               if (br->InheritsFrom(TBranchElement::Class())) {
                  ((TBranchElement*) br)->ResetDeleteObject();
               }
            } else {
               Warning("CopyAddresses", "Could not find branch named '%s' in tree named '%s'", branch->GetName(), tree->GetName());
            }
         } else {
            tleaf->SetAddress(leaf->GetValuePointer());
         }
      }
   }

   if (undo &&
       ( tree->IsA()->InheritsFrom("TNtuple") || tree->IsA()->InheritsFrom("TNtupleD") )
       ) {
      tree->ResetBranchAddresses();
   }
}

namespace {

   enum EOnIndexError { kDrop, kKeep, kBuild };

   static Bool_t R__HandleIndex(EOnIndexError onIndexError, TTree *newtree, TTree *oldtree)
   {
      // Return true if we should continue to handle indices, false otherwise.

      Bool_t withIndex = kTRUE;

      if ( newtree->GetTreeIndex() ) {
         if ( oldtree->GetTree()->GetTreeIndex() == 0 ) {
            switch (onIndexError) {
               case kDrop:
                  delete newtree->GetTreeIndex();
                  newtree->SetTreeIndex(0);
                  withIndex = kFALSE;
                  break;
               case kKeep:
                  // Nothing to do really.
                  break;
               case kBuild:
                  // Build the index then copy it
                  if (oldtree->GetTree()->BuildIndex(newtree->GetTreeIndex()->GetMajorName(), newtree->GetTreeIndex()->GetMinorName())) {
                     newtree->GetTreeIndex()->Append(oldtree->GetTree()->GetTreeIndex(), kTRUE);
                     // Clean up
                     delete oldtree->GetTree()->GetTreeIndex();
                     oldtree->GetTree()->SetTreeIndex(0);
                  }
                  break;
            }
         } else {
            newtree->GetTreeIndex()->Append(oldtree->GetTree()->GetTreeIndex(), kTRUE);
         }
      } else if ( oldtree->GetTree()->GetTreeIndex() != 0 ) {
         // We discover the first index in the middle of the chain.
         switch (onIndexError) {
            case kDrop:
               // Nothing to do really.
               break;
            case kKeep: {
               TVirtualIndex *index = (TVirtualIndex*) oldtree->GetTree()->GetTreeIndex()->Clone();
               index->SetTree(newtree);
               newtree->SetTreeIndex(index);
               break;
            }
            case kBuild:
               if (newtree->GetEntries() == 0) {
                  // Start an index.
                  TVirtualIndex *index = (TVirtualIndex*) oldtree->GetTree()->GetTreeIndex()->Clone();
                  index->SetTree(newtree);
                  newtree->SetTreeIndex(index);
               } else {
                  // Build the index so far.
                  if (newtree->BuildIndex(oldtree->GetTree()->GetTreeIndex()->GetMajorName(), oldtree->GetTree()->GetTreeIndex()->GetMinorName())) {
                     newtree->GetTreeIndex()->Append(oldtree->GetTree()->GetTreeIndex(), kTRUE);
                  }
               }
               break;
         }
      } else if ( onIndexError == kDrop ) {
         // There is no index on this or on tree->GetTree(), we know we have to ignore any further
         // index
         withIndex = kFALSE;
      }
      return withIndex;
   }
}

//______________________________________________________________________________
Long64_t TTree::CopyEntries(TTree* tree, Long64_t nentries /* = -1 */, Option_t* option /* = "" */)
{
   // Copy nentries from given tree to this tree.
   // This routines assumes that the branches that intended to be copied are
   // already connected.   The typical case is that this tree was created using
   // tree->CloneTree(0).
   //
   // By default copy all entries.
   //
   // Returns number of bytes copied to this tree.
   //
   // If 'option' contains the word 'fast' and nentries is -1, the cloning will be
   // done without unzipping or unstreaming the baskets (i.e., a direct copy of the
   // raw bytes on disk).
   //
   // When 'fast' is specified, 'option' can also contains a sorting order for the
   // baskets in the output file.
   //
   // There are currently 3 supported sorting order:
   //    SortBasketsByOffset (the default)
   //    SortBasketsByBranch
   //    SortBasketsByEntry
   //
   // See TTree::CloneTree for a detailed explanation of the semantics of these 3 options.
   //
   // If the tree or any of the underlying tree of the chain has an index, that index and any
   // index in the subsequent underlying TTree objects will be merged.
   //
   // There are currently three 'options' to control this merging:
   //    NoIndex             : all the TTreeIndex object are dropped.
   //    DropIndexOnError    : if any of the underlying TTree object do no have a TTreeIndex,
   //                          they are all dropped.
   //    AsIsIndexOnError [default]: In case of missing TTreeIndex, the resulting TTree index has gaps.
   //    BuildIndexOnError : If any of the underlying TTree objects do not have a TTreeIndex,
   //                          all TTreeIndex are 'ignored' and the missing piece are rebuilt.

   if (!tree) {
      return 0;
   }
   // Options
   TString opt = option;
   opt.ToLower();
   Bool_t fastClone = opt.Contains("fast");
   Bool_t withIndex = !opt.Contains("noindex");
   EOnIndexError onIndexError;
   if (opt.Contains("asisindex")) {
      onIndexError = kKeep;
   } else if (opt.Contains("buildindex")) {
      onIndexError = kBuild;
   } else if (opt.Contains("dropindex")) {
      onIndexError = kDrop;
   } else {
      onIndexError = kBuild;
   }

   Long64_t nbytes = 0;
   Long64_t treeEntries = tree->GetEntriesFast();
   if (nentries < 0) {
      nentries = treeEntries;
   } else if (nentries > treeEntries) {
      nentries = treeEntries;
   }

   if (fastClone && (nentries < 0 || nentries == tree->GetEntriesFast())) {
      // Quickly copy the basket without decompression and streaming.
      Long64_t totbytes = GetTotBytes();
      for (Long64_t i = 0; i < nentries; i += tree->GetTree()->GetEntries()) {
         if (tree->LoadTree(i) < 0) {
            break;
         }
         if ( withIndex ) {
            withIndex = R__HandleIndex( onIndexError, this, tree );
         }
         if (this->GetDirectory()) {
            TFile* file2 = this->GetDirectory()->GetFile();
            if (file2 && (file2->GetEND() > TTree::GetMaxTreeSize())) {
               if (this->GetDirectory() == (TDirectory*) file2) {
                  this->ChangeFile(file2);
               }
            }
         }
         TTreeCloner cloner(tree->GetTree(), this, option, TTreeCloner::kNoWarnings);
         if (cloner.IsValid()) {
            this->SetEntries(this->GetEntries() + tree->GetTree()->GetEntries());
            cloner.Exec();
         } else {
            if (i == 0) {
               Warning("CopyEntries","%s",cloner.GetWarning());
               // If the first cloning does not work, something is really wrong
               // (since apriori the source and target are exactly the same structure!)
               return -1;
            } else {
               if (cloner.NeedConversion()) {
                  TTree *localtree = tree->GetTree();
                  Long64_t tentries = localtree->GetEntries();
                  for (Long64_t ii = 0; ii < tentries; ii++) {
                     if (localtree->GetEntry(ii) <= 0) {
                        break;
                     }
                     this->Fill();
                  }
                  if (this->GetTreeIndex()) {
                     this->GetTreeIndex()->Append(tree->GetTree()->GetTreeIndex(), kTRUE);
                  }
               } else {
                  Warning("CopyEntries","%s",cloner.GetWarning());
                  if (tree->GetDirectory() && tree->GetDirectory()->GetFile()) {
                     Warning("CopyEntries", "Skipped file %s\n", tree->GetDirectory()->GetFile()->GetName());
                  } else {
                     Warning("CopyEntries", "Skipped file number %d\n", tree->GetTreeNumber());
                  }
               }
            }
         }

      }
      if (this->GetTreeIndex()) {
         this->GetTreeIndex()->Append(0,kFALSE); // Force the sorting
      }
      nbytes = GetTotBytes() - totbytes;
   } else {
      if (nentries < 0) {
         nentries = treeEntries;
      } else if (nentries > treeEntries) {
         nentries = treeEntries;
      }
      Int_t treenumber = -1;
      for (Long64_t i = 0; i < nentries; i++) {
         if (tree->LoadTree(i) < 0) {
            break;
         }
         if (treenumber != tree->GetTreeNumber()) {
            if ( withIndex ) {
               withIndex = R__HandleIndex( onIndexError, this, tree );
            }
            treenumber = tree->GetTreeNumber();
         }
         if (tree->GetEntry(i) <= 0) {
            break;
         }
         nbytes += this->Fill();
      }
      if (this->GetTreeIndex()) {
         this->GetTreeIndex()->Append(0,kFALSE); // Force the sorting
      }
   }
   return nbytes;
}

//______________________________________________________________________________
TTree* TTree::CopyTree(const char* selection, Option_t* option /* = 0 */, Long64_t nentries /* = 1000000000 */, Long64_t firstentry /* = 0 */)
{
   // Copy a tree with selection.
   //
   // IMPORTANT:
   //
   //   The returned copied tree stays connected with the original tree
   //   until the original tree is deleted.  In particular, any changes
   //   to the branch addresses in the original tree are also made to
   //   the copied tree.  Any changes made to the branch addresses of the
   //   copied tree are overridden anytime the original tree changes its
   //   branch addresses.  When the original tree is deleted, all the
   //   branch addresses of the copied tree are set to zero.
   //
   // For examples of CopyTree, see the tutorials:
   //
   // copytree
   //
   // Example macro to copy a subset of a tree to a new tree.
   //
   // The input file was generated by running the program in
   // $ROOTSYS/test/Event in this way:
   //
   //      ./Event 1000 1 1 1
   //
   // copytree2
   //
   // Example macro to copy a subset of a tree to a new tree.
   //
   // One branch of the new tree is written to a separate file.
   //
   // The input file was generated by running the program in
   // $ROOTSYS/test/Event in this way:
   //
   //      ./Event 1000 1 1 1
   //
   // copytree3
   //
   // Example macro to copy a subset of a tree to a new tree.
   //
   // Only selected entries are copied to the new tree.
   // NOTE that only the active branches are copied.
   //

   GetPlayer();
   if (fPlayer) {
      return fPlayer->CopyTree(selection, option, nentries, firstentry);
   }
   return 0;
}

//______________________________________________________________________________
TBasket* TTree::CreateBasket(TBranch* branch)
{
   // Create a basket for this tree and given branch.
   if (!branch) {
      return 0;
   }
   return new TBasket(branch->GetName(), GetName(), branch);
}

//______________________________________________________________________________
void TTree::Delete(Option_t* option /* = "" */)
{
   // Delete this tree from memory or/and disk.
   //
   //  if option == "all" delete Tree object from memory AND from disk
   //                     all baskets on disk are deleted. All keys with same name
   //                     are deleted.
   //  if option =="" only Tree object in memory is deleted.

   TFile *file = GetCurrentFile();

   // delete all baskets and header from file
   if (file && !strcmp(option,"all")) {
      if (!file->IsWritable()) {
         Error("Delete","File : %s is not writable, cannot delete Tree:%s", file->GetName(),GetName());
         return;
      }

      //find key and import Tree header in memory
      TKey *key = fDirectory->GetKey(GetName());
      if (!key) return;

      TDirectory *dirsav = gDirectory;
      file->cd();

      //get list of leaves and loop on all the branches baskets
      TIter next(GetListOfLeaves());
      TLeaf *leaf;
      char header[16];
      Int_t ntot  = 0;
      Int_t nbask = 0;
      Int_t nbytes,objlen,keylen;
      while ((leaf = (TLeaf*)next())) {
         TBranch *branch = leaf->GetBranch();
         Int_t nbaskets = branch->GetMaxBaskets();
         for (Int_t i=0;i<nbaskets;i++) {
            Long64_t pos = branch->GetBasketSeek(i);
            if (!pos) continue;
            TFile *branchFile = branch->GetFile();
            if (!branchFile) continue;
            branchFile->GetRecordHeader(header,pos,16,nbytes,objlen,keylen);
            if (nbytes <= 0) continue;
            branchFile->MakeFree(pos,pos+nbytes-1);
            ntot += nbytes;
            nbask++;
         }
      }

      // delete Tree header key and all keys with the same name
      // A Tree may have been saved many times. Previous cycles are invalid.
      while (key) {
         ntot += key->GetNbytes();
         key->Delete();
         delete key;
         key = fDirectory->GetKey(GetName());
      }
      if (dirsav) dirsav->cd();
      if (gDebug) printf(" Deleting Tree: %s: %d baskets deleted. Total space freed = %d bytes\n",GetName(),nbask,ntot);
   }

   if (fDirectory) {
      fDirectory->Remove(this);
      //delete the file cache if it points to this Tree
      MoveReadCache(file,0);
      fDirectory = 0;
      ResetBit(kMustCleanup);
   }

   // Delete object from CINT symbol table so it can not be used anymore.
   gCling->DeleteGlobal(this);

   // Warning: We have intentional invalidated this object while inside a member function!
   delete this;
}

 //______________________________________________________________________________
void TTree::DirectoryAutoAdd(TDirectory* dir)
{
   // Called by TKey and TObject::Clone to automatically add us to a directory
   // when we are read from a file.

   if (fDirectory == dir) return;
   if (fDirectory) {
      fDirectory->Remove(this);
      // Delete or move the file cache if it points to this Tree
      TFile *file = fDirectory->GetFile();
      MoveReadCache(file,dir);
   }
   fDirectory = dir;
   TBranch* b = 0;
   TIter next(GetListOfBranches());
   while((b = (TBranch*) next())) {
      b->UpdateFile();
   }
   if (fBranchRef) {
      fBranchRef->UpdateFile();
   }
   if (fDirectory) fDirectory->Append(this);
}

//______________________________________________________________________________
Long64_t TTree::Draw(const char* varexp, const TCut& selection, Option_t* option, Long64_t nentries, Long64_t firstentry)
{
   // Draw expression varexp for specified entries.
   // Returns -1 in case of error or number of selected events in case of success.
   //
   //      This function accepts TCut objects as arguments.
   //      Useful to use the string operator +
   //         example:
   //            ntuple.Draw("x",cut1+cut2+cut3);
   //

   return TTree::Draw(varexp, selection.GetTitle(), option, nentries, firstentry);
}

//______________________________________________________________________________
Long64_t TTree::Draw(const char* varexp, const char* selection, Option_t* option, Long64_t nentries, Long64_t firstentry)
{
   // Draw expression varexp for specified entries.
   // Returns -1 in case of error or number of selected events in case of success.
   //
   //  varexp is an expression of the general form
   //   - "e1"           produces a 1-d histogram (TH1F) of expression "e1"
   //   - "e1:e2"        produces an unbinned 2-d scatter-plot (TGraph) of "e1"
   //                    on the y-axis versus "e2" on the x-axis
   //   - "e1:e2:e3"     produces an unbinned 3-d scatter-plot (TPolyMarker3D) of "e1"
   //                    versus "e2" versus "e3" on the x-, y-, z-axis, respectively.
   //   - "e1:e2:e3:e4"  produces an unbinned 3-d scatter-plot (TPolyMarker3D) of "e1"
   //                    versus "e2" versus "e3" and "e4" mapped on the color number.
   //  (to create histograms in the 2, 3, and 4 dimensional case, see section "Saving
   //  the result of Draw to an histogram")
   //
   //  Example:
   //     varexp = x     simplest case: draw a 1-Dim distribution of column named x
   //            = sqrt(x)            : draw distribution of sqrt(x)
   //            = x*y/z
   //            = y:sqrt(x) 2-Dim distribution of y versus sqrt(x)
   //            = px:py:pz:2.5*E  produces a 3-d scatter-plot of px vs py ps pz
   //              and the color number of each marker will be 2.5*E.
   //              If the color number is negative it is set to 0.
   //              If the color number is greater than the current number of colors
   //                 it is set to the highest color number.
   //              The default number of colors is 50.
   //              see TStyle::SetPalette for setting a new color palette.
   //
   //  Note that the variables e1, e2 or e3 may contain a selection.
   //  example, if e1= x*(y<0), the value histogrammed will be x if y<0
   //  and will be 0 otherwise.
   //
   //  The expressions can use all the operations and build-in functions
   //  supported by TFormula (See TFormula::Analyze), including free
   //  standing function taking numerical arguments (TMath::Bessel).
   //  In addition, you can call member functions taking numerical
   //  arguments. For example:
   //      - "TMath::BreitWigner(fPx,3,2)"
   //      - "event.GetHistogram().GetXaxis().GetXmax()"
   //  Note: You can only pass expression that depend on the TTree's data
   //  to static functions and you can only call non-static member function
   //  with 'fixed' parameters.
   //
   //  selection is an expression with a combination of the columns.
   //  In a selection all the C++ operators are authorized.
   //  The value corresponding to the selection expression is used as a weight
   //  to fill the histogram.
   //  If the expression includes only boolean operations, the result
   //  is 0 or 1. If the result is 0, the histogram is not filled.
   //  In general, the expression may be of the form:
   //      value*(boolean expression)
   //  if boolean expression is true, the histogram is filled with
   //  a weight = value.
   //  Examples:
   //      selection1 = "x<y && sqrt(z)>3.2"
   //      selection2 = "(x+y)*(sqrt(z)>3.2)"
   //  selection1 returns a weight = 0 or 1
   //  selection2 returns a weight = x+y if sqrt(z)>3.2
   //             returns a weight = 0 otherwise.
   //
   //  option is the drawing option.
   //    - See TH1::Draw for the list of all drawing options.
   //    - If option COL is specified when varexp has three fields:
   //            tree.Draw("e1:e2:e3","","col");
   //      a 2D scatter is produced with e1 vs e2, and e3 is mapped on the color
   //      table. The colors for e3 are evaluated once in linear scale before
   //      painting. Therefore changing the pad to log scale along Z as no effect
   //      on the colors.
   //    - If option contains the string "goff", no graphics is generated.
   //
   //  nentries is the number of entries to process (default is all)
   //  first is the first entry to process (default is 0)
   //
   //  This function returns the number of selected entries. It returns -1
   //  if an error occurs.
   //
   //     Drawing expressions using arrays and array elements
   //     ===================================================
   // Let assumes, a leaf fMatrix, on the branch fEvent, which is a 3 by 3 array,
   // or a TClonesArray.
   // In a TTree::Draw expression you can now access fMatrix using the following
   // syntaxes:
   //
   //   String passed    What is used for each entry of the tree
   //
   //   "fMatrix"       the 9 elements of fMatrix
   //   "fMatrix[][]"   the 9 elements of fMatrix
   //   "fMatrix[2][2]" only the elements fMatrix[2][2]
   //   "fMatrix[1]"    the 3 elements fMatrix[1][0], fMatrix[1][1] and fMatrix[1][2]
   //   "fMatrix[1][]"  the 3 elements fMatrix[1][0], fMatrix[1][1] and fMatrix[1][2]
   //   "fMatrix[][0]"  the 3 elements fMatrix[0][0], fMatrix[1][0] and fMatrix[2][0]
   //
   //   "fEvent.fMatrix...." same as "fMatrix..." (unless there is more than one leaf named fMatrix!).
   //
   // In summary, if a specific index is not specified for a dimension, TTree::Draw
   // will loop through all the indices along this dimension.  Leaving off the
   // last (right most) dimension of specifying then with the two characters '[]'
   // is equivalent.  For variable size arrays (and TClonesArray) the range
   // of the first dimension is recalculated for each entry of the tree.
   // You can also specify the index as an expression of any other variables from the
   // tree.
   //
   // TTree::Draw also now properly handling operations involving 2 or more arrays.
   //
   // Let assume a second matrix fResults[5][2], here are a sample of some
   // of the possible combinations, the number of elements they produce and
   // the loop used:
   //
   //  expression                       element(s)  Loop
   //
   //  "fMatrix[2][1] - fResults[5][2]"   one     no loop
   //  "fMatrix[2][]  - fResults[5][2]"   three   on 2nd dim fMatrix
   //  "fMatrix[2][]  - fResults[5][]"    two     on both 2nd dimensions
   //  "fMatrix[][2]  - fResults[][1]"    three   on both 1st dimensions
   //  "fMatrix[][2]  - fResults[][]"     six     on both 1st and 2nd dimensions of
   //                                             fResults
   //  "fMatrix[][2]  - fResults[3][]"    two     on 1st dim of fMatrix and 2nd of
   //                                             fResults (at the same time)
   //  "fMatrix[][]   - fResults[][]"     six     on 1st dim then on  2nd dim
   //
   //  "fMatrix[][fResult[][]]"           30      on 1st dim of fMatrix then on both
   //                                             dimensions of fResults.  The value
   //                                             if fResults[j][k] is used as the second
   //                                             index of fMatrix.
   //
   //
   // In summary, TTree::Draw loops through all unspecified dimensions.  To
   // figure out the range of each loop, we match each unspecified dimension
   // from left to right (ignoring ALL dimensions for which an index has been
   // specified), in the equivalent loop matched dimensions use the same index
   // and are restricted to the smallest range (of only the matched dimensions).
   // When involving variable arrays, the range can of course be different
   // for each entry of the tree.
   //
   // So the loop equivalent to "fMatrix[][2] - fResults[3][]" is:
   //
   //    for (Int_t i0; i < min(3,2); i++) {
   //       use the value of (fMatrix[i0][2] - fMatrix[3][i0])
   //    }
   //
   // So the loop equivalent to "fMatrix[][2] - fResults[][]" is:
   //
   //    for (Int_t i0; i < min(3,5); i++) {
   //       for (Int_t i1; i1 < 2; i1++) {
   //          use the value of (fMatrix[i0][2] - fMatrix[i0][i1])
   //       }
   //    }
   //
   // So the loop equivalent to "fMatrix[][] - fResults[][]" is:
   //
   //    for (Int_t i0; i < min(3,5); i++) {
   //       for (Int_t i1; i1 < min(3,2); i1++) {
   //          use the value of (fMatrix[i0][i1] - fMatrix[i0][i1])
   //       }
   //    }
   //
   // So the loop equivalent to "fMatrix[][fResults[][]]" is:
   //
   //    for (Int_t i0; i0 < 3; i0++) {
   //       for (Int_t j2; j2 < 5; j2++) {
   //          for (Int_t j3; j3 < 2; j3++) {
   //             i1 = fResults[j2][j3];
   //             use the value of fMatrix[i0][i1]
   //       }
   //    }
   //
   //     Retrieving the result of Draw
   //     =============================
   //
   //  By default the temporary histogram created is called "htemp", but only in
   //  the one dimensional Draw("e1") it contains the TTree's data points. For
   //  a two dimensional Draw, the data is filled into a TGraph which is named
   //  "Graph". They can be retrieved by calling
   //    TH1F *htemp = (TH1F*)gPad->GetPrimitive("htemp"); // 1D
   //    TGraph *graph = (TGraph*)gPad->GetPrimitive("Graph"); // 2D
   //
   //  For a three and four dimensional Draw the TPolyMarker3D is unnamed, and
   //  cannot be retrieved.
   //
   //  gPad always contains a TH1 derived object called "htemp" which allows to
   //  access the axes:
   //    TGraph *graph = (TGraph*)gPad->GetPrimitive("Graph"); // 2D
   //    TH2F   *htemp = (TH2F*)gPad->GetPrimitive("htemp"); // empty, but has axes
   //    TAxis  *xaxis = htemp->GetXaxis();
   //
   //     Saving the result of Draw to an histogram
   //     =========================================
   //
   //  If varexp0 contains >>hnew (following the variable(s) name(s),
   //  the new histogram created is called hnew and it is kept in the current
   //  directory (and also the current pad). This works for all dimensions.
   //  Example:
   //    tree.Draw("sqrt(x)>>hsqrt","y>0")
   //    will draw sqrt(x) and save the histogram as "hsqrt" in the current
   //    directory.  To retrieve it do:
   //    TH1F *hsqrt = (TH1F*)gDirectory->Get("hsqrt");
   //
   //  The binning information is taken from the environment variables
   //
   //     Hist.Binning.?D.?
   //
   //  In addition, the name of the histogram can be followed by up to 9
   //  numbers between '(' and ')', where the numbers describe the
   //  following:
   //
   //   1 - bins in x-direction
   //   2 - lower limit in x-direction
   //   3 - upper limit in x-direction
   //   4-6 same for y-direction
   //   7-9 same for z-direction
   //
   //   When a new binning is used the new value will become the default.
   //   Values can be skipped.
   //  Example:
   //    tree.Draw("sqrt(x)>>hsqrt(500,10,20)")
   //          // plot sqrt(x) between 10 and 20 using 500 bins
   //    tree.Draw("sqrt(x):sin(y)>>hsqrt(100,10,60,50,.1,.5)")
   //          // plot sqrt(x) against sin(y)
   //          // 100 bins in x-direction; lower limit on x-axis is 10; upper limit is 60
   //          //  50 bins in y-direction; lower limit on y-axis is .1; upper limit is .5
   //
   //  By default, the specified histogram is reset.
   //  To continue to append data to an existing histogram, use "+" in front
   //  of the histogram name.
   //  A '+' in front of the histogram name is ignored, when the name is followed by
   //  binning information as described in the previous paragraph.
   //    tree.Draw("sqrt(x)>>+hsqrt","y>0")
   //      will not reset hsqrt, but will continue filling.
   //  This works for 1-D, 2-D and 3-D histograms.
   //
   //     Accessing collection objects
   //     ============================
   //
   //  TTree::Draw default's handling of collections is to assume that any
   //  request on a collection pertain to it content.  For example, if fTracks
   //  is a collection of Track objects, the following:
   //      tree->Draw("event.fTracks.fPx");
   //  will plot the value of fPx for each Track objects inside the collection.
   //  Also
   //     tree->Draw("event.fTracks.size()");
   //  would plot the result of the member function Track::size() for each
   //  Track object inside the collection.
   //  To access information about the collection itself, TTree::Draw support
   //  the '@' notation.  If a variable which points to a collection is prefixed
   //  or postfixed with '@', the next part of the expression will pertain to
   //  the collection object.  For example:
   //     tree->Draw("event.@fTracks.size()");
   //  will plot the size of the collection referred to by fTracks (i.e the number
   //  of Track objects).
   //
   //     Drawing 'objects'
   //     =================
   //
   //  When a class has a member function named AsDouble or AsString, requesting
   //  to directly draw the object will imply a call to one of the 2 functions.
   //  If both AsDouble and AsString are present, AsDouble will be used.
   //  AsString can return either a char*, a std::string or a TString.s
   //  For example, the following
   //     tree->Draw("event.myTTimeStamp");
   //  will draw the same histogram as
   //     tree->Draw("event.myTTimeStamp.AsDouble()");
   //  In addition, when the object is a type TString or std::string, TTree::Draw
   //  will call respectively TString::Data and std::string::c_str()
   //
   //  If the object is a TBits, the histogram will contain the index of the bit
   //  that are turned on.
   //
   //     Retrieving  information about the tree itself.
   //     ============================================
   //
   //  You can refer to the tree (or chain) containing the data by using the
   //  string 'This'.
   //  You can then could any TTree methods.  For example:
   //     tree->Draw("This->GetReadEntry()");
   //  will display the local entry numbers be read.
   //     tree->Draw("This->GetUserInfo()->At(0)->GetName()");
   //  will display the name of the first 'user info' object.
   //
   //     Special functions and variables
   //     ===============================
   //
   //  Entry$:  A TTree::Draw formula can use the special variable Entry$
   //  to access the entry number being read.  For example to draw every
   //  other entry use:
   //    tree.Draw("myvar","Entry$%2==0");
   //
   //  Entry$      : return the current entry number (== TTree::GetReadEntry())
   //  LocalEntry$ : return the current entry number in the current tree of a
   //                chain (== GetTree()->GetReadEntry())
   //  Entries$    : return the total number of entries (== TTree::GetEntries())
   //  Length$     : return the total number of element of this formula for this
   //                 entry (==TTreeFormula::GetNdata())
   //  Iteration$: return the current iteration over this formula for this
   //                 entry (i.e. varies from 0 to Length$).
   //
   //  Length$(formula): return the total number of element of the formula given as a
   //                    parameter.
   //  Sum$(formula): return the sum of the value of the elements of the formula given
   //                    as a parameter.  For example the mean for all the elements in
   //                    one entry can be calculated with:
   //                Sum$(formula)/Length$(formula)
   //  Min$(formula): return the minimun (within one TTree entry) of the value of the
   //                    elements of the formula given as a parameter.
   //  Max$(formula): return the maximum (within one TTree entry) of the value of the
   //                    elements of the formula given as a parameter.
   //  MinIf$(formula,condition)
   //  MaxIf$(formula,condition): return the minimum (maximum) (within one TTree entry)
   //                    of the value of the elements of the formula given as a parameter
   //                    if they match the condition. If no element matches the condition,
   //                    the result is zero.  To avoid the resulting peak at zero, use the
   //                    pattern:
   //    tree->Draw("MinIf$(formula,condition)","condition");
   //                    which will avoid calculation MinIf$ for the entries that have no match
   //                    for the condition.
   //
   //  Alt$(primary,alternate) : return the value of "primary" if it is available
   //                 for the current iteration otherwise return the value of "alternate".
   //                 For example, with arr1[3] and arr2[2]
   //    tree->Draw("arr1+Alt$(arr2,0)");
   //                 will draw arr1[0]+arr2[0] ; arr1[1]+arr2[1] and arr1[2]+0
   //                 Or with a variable size array arr3
   //    tree->Draw("Alt$(arr3[0],0)+Alt$(arr3[1],0)+Alt$(arr3[2],0)");
   //                 will draw the sum arr3 for the index 0 to min(2,actual_size_of_arr3-1)
   //                 As a comparison
   //    tree->Draw("arr3[0]+arr3[1]+arr3[2]");
   //                 will draw the sum arr3 for the index 0 to 2 only if the
   //                 actual_size_of_arr3 is greater or equal to 3.
   //                 Note that the array in 'primary' is flattened/linearized thus using
   //                 Alt$ with multi-dimensional arrays of different dimensions in unlikely
   //                 to yield the expected results.  To visualize a bit more what elements
   //                 would be matched by TTree::Draw, TTree::Scan can be used:
   //    tree->Scan("arr1:Alt$(arr2,0)");
   //                 will print on one line the value of arr1 and (arr2,0) that will be
   //                 matched by
   //    tree->Draw("arr1-Alt$(arr2,0)");
   //
   //  The ternary operator is not directly supported in TTree::Draw however, to plot the
   //  equivalent of 'var2<20 ? -99 : var1', you can use:
   //     tree->Draw("(var2<20)*99+(var2>=20)*var1","");
   //
   //     Drawing a user function accessing the TTree data directly
   //     =========================================================
   //
   //  If the formula contains  a file name, TTree::MakeProxy will be used
   //  to load and execute this file.   In particular it will draw the
   //  result of a function with the same name as the file.  The function
   //  will be executed in a context where the name of the branches can
   //  be used as a C++ variable.
   //
   //  For example draw px using the file hsimple.root (generated by the
   //  hsimple.C tutorial), we need a file named hsimple.cxx:
   //
   //     double hsimple() {
   //        return px;
   //     }
   //
   //  MakeProxy can then be used indirectly via the TTree::Draw interface
   //  as follow:
   //     new TFile("hsimple.root")
   //     ntuple->Draw("hsimple.cxx");
   //
   //  A more complete example is available in the tutorials directory:
   //    h1analysisProxy.cxx , h1analysProxy.h and h1analysisProxyCut.C
   //  which reimplement the selector found in h1analysis.C
   //
   //  The main features of this facility are:
   //
   //    * on-demand loading of branches
   //    * ability to use the 'branchname' as if it was a data member
   //    * protection against array out-of-bound
   //    * ability to use the branch data as object (when the user code is available)
   //
   //  See TTree::MakeProxy for more details.
   //
   //     Making a Profile histogram
   //     ==========================
   //  In case of a 2-Dim expression, one can generate a TProfile histogram
   //  instead of a TH2F histogram by specyfying option=prof or option=profs
   //  or option=profi or option=profg ; the trailing letter select the way
   //  the bin error are computed, See TProfile2D::SetErrorOption for
   //  details on the differences.
   //  The option=prof is automatically selected in case of y:x>>pf
   //  where pf is an existing TProfile histogram.
   //
   //     Making a 2D Profile histogram
   //     ==========================
   //  In case of a 3-Dim expression, one can generate a TProfile2D histogram
   //  instead of a TH3F histogram by specifying option=prof or option=profs.
   //  or option=profi or option=profg ; the trailing letter select the way
   //  the bin error are computed, See TProfile2D::SetErrorOption for
   //  details on the differences.
   //  The option=prof is automatically selected in case of z:y:x>>pf
   //  where pf is an existing TProfile2D histogram.
   //
   //     Making a 5D plot using GL
   //     =========================
   //  If option GL5D is specified together with 5 variables, a 5D plot is drawn
   //  using OpenGL. See $ROOTSYS/tutorials/tree/staff.C as example.
   //
   //     Making a parallel coordinates plot
   //     ==================================
   //  In case of a 2-Dim or more expression with the option=para, one can generate
   //  a parallel coordinates plot. With that option, the number of dimensions is
   //  arbitrary. Giving more than 4 variables without the option=para or
   //  option=candle or option=goff will produce an error.
   //
   //     Making a candle sticks chart
   //     ============================
   //  In case of a 2-Dim or more expression with the option=candle, one can generate
   //  a candle sticks chart. With that option, the number of dimensions is
   //  arbitrary. Giving more than 4 variables without the option=para or
   //  option=candle or option=goff will produce an error.
   //
   //     Normalizing the output histogram to 1
   //     ====================================
   //  When option contains "norm" the output histogram is normalized to 1.
   //
   //     Saving the result of Draw to a TEventList, a TEntryList or a TEntryListArray
   //     ============================================================================
   //  TTree::Draw can be used to fill a TEventList object (list of entry numbers)
   //  instead of histogramming one variable.
   //  If varexp0 has the form >>elist , a TEventList object named "elist"
   //  is created in the current directory. elist will contain the list
   //  of entry numbers satisfying the current selection.
   //  If option "entrylist" is used, a TEntryList object is created
   //  If the selection contains arrays, vectors or any container class and option
   //  "entrylistarray" is used, a TEntryListArray object is created
   //  containing also the subentries satisfying the selection, i.e. the indices of
   //  the branches which hold containers classes.
   //  Example:
   //    tree.Draw(">>yplus","y>0")
   //    will create a TEventList object named "yplus" in the current directory.
   //    In an interactive session, one can type (after TTree::Draw)
   //       yplus.Print("all")
   //    to print the list of entry numbers in the list.
   //    tree.Draw(">>yplus", "y>0", "entrylist")
   //    will create a TEntryList object names "yplus" in the current directory
   //    tree.Draw(">>yplus", "y>0", "entrylistarray")
   //    will create a TEntryListArray object names "yplus" in the current directory
   //
   //  By default, the specified entry list is reset.
   //  To continue to append data to an existing list, use "+" in front
   //  of the list name;
   //    tree.Draw(">>+yplus","y>0")
   //      will not reset yplus, but will enter the selected entries at the end
   //      of the existing list.
   //
   //      Using a TEventList, TEntryList or TEntryListArray as Input
   //      ===========================
   //  Once a TEventList or a TEntryList object has been generated, it can be used as input
   //  for TTree::Draw. Use TTree::SetEventList or TTree::SetEntryList to set the
   //  current event list
   //  Example1:
   //     TEventList *elist = (TEventList*)gDirectory->Get("yplus");
   //     tree->SetEventList(elist);
   //     tree->Draw("py");
   //  Example2:
   //     TEntryList *elist = (TEntryList*)gDirectory->Get("yplus");
   //     tree->SetEntryList(elist);
   //     tree->Draw("py");
   //  If a TEventList object is used as input, a new TEntryList object is created
   //  inside the SetEventList function. In case of a TChain, all tree headers are loaded
   //  for this transformation. This new object is owned by the chain and is deleted
   //  with it, unless the user extracts it by calling GetEntryList() function.
   //  See also comments to SetEventList() function of TTree and TChain.
   //
   //  If arrays are used in the selection criteria and TEntryListArray is not used,
   //  all the entries that have at least one element of the array that satisfy the selection
   //  are entered in the list.
   //  Example:
   //      tree.Draw(">>pyplus","fTracks.fPy>0");
   //      tree->SetEventList(pyplus);
   //      tree->Draw("fTracks.fPy");
   //  will draw the fPy of ALL tracks in event with at least one track with
   //  a positive fPy.
   //
   //  To select only the elements that did match the original selection
   //  use TEventList::SetReapplyCut or TEntryList::SetReapplyCut.
   //  Example:
   //      tree.Draw(">>pyplus","fTracks.fPy>0");
   //      pyplus->SetReapplyCut(kTRUE);
   //      tree->SetEventList(pyplus);
   //      tree->Draw("fTracks.fPy");
   //  will draw the fPy of only the tracks that have a positive fPy.
   //
   //  To draw only the elements that match a selection in case of arrays,
   //  you can also use TEntryListArray (faster in case of a more general selection).
   //  Example:
   //      tree.Draw(">>pyplus","fTracks.fPy>0", "entrylistarray");
   //      tree->SetEntryList(pyplus);
   //      tree->Draw("fTracks.fPy");
   //
   //  will draw the fPy of only the tracks that have a positive fPy,
   //  but without redoing the selection.
   //
   //  Note: Use tree->SetEventList(0) if you do not want use the list as input.
   //
   //      How to obtain more info from TTree::Draw
   //      ========================================
   //
   //  Once TTree::Draw has been called, it is possible to access useful
   //  information still stored in the TTree object via the following functions:
   //    -GetSelectedRows()    //return the number of values accepted by the
   //                          //selection expression. In case where no selection
   //                          //was specified, returns the number of values processed.
   //    -GetV1()              //returns a pointer to the double array of V1
   //    -GetV2()              //returns a pointer to the double array of V2
   //    -GetV3()              //returns a pointer to the double array of V3
   //    -GetV4()              //returns a pointer to the double array of V4
   //    -GetW()               //returns a pointer to the double array of Weights
   //                          //where weight equal the result of the selection expression.
   //   where V1,V2,V3 correspond to the expressions in
   //   TTree::Draw("V1:V2:V3:V4",selection);
   //   If the expression has more than 4 component use GetVal(index)
   //
   //   Example:
   //    Root > ntuple->Draw("py:px","pz>4");
   //    Root > TGraph *gr = new TGraph(ntuple->GetSelectedRows(),
   //                                   ntuple->GetV2(), ntuple->GetV1());
   //    Root > gr->Draw("ap"); //draw graph in current pad
   //    creates a TGraph object with a number of points corresponding to the
   //    number of entries selected by the expression "pz>4", the x points of the graph
   //    being the px values of the Tree and the y points the py values.
   //
   //    Important note: By default TTree::Draw creates the arrays obtained
   //    with GetW, GetV1, GetV2, GetV3, GetV4, GetVal with a length corresponding
   //    to the parameter fEstimate.  The content will be the last
   //            GetSelectedRows() % GetEstimate()
   //    values calculated.
   //    By default fEstimate=1000000 and can be modified
   //    via TTree::SetEstimate. To keep in memory all the results (in case
   //    where there is only one result per entry), use
   //       tree->SetEstimate(tree->GetEntries()+1); // same as tree->SetEstimate(-1);
   //    You must call SetEstimate if the expected number of selected rows
   //    you need to look at is greater than 1000000.
   //
   //    You can use the option "goff" to turn off the graphics output
   //    of TTree::Draw in the above example.
   //
   //           Automatic interface to TTree::Draw via the TTreeViewer
   //           ======================================================
   //
   //    A complete graphical interface to this function is implemented
   //    in the class TTreeViewer.
   //    To start the TTreeViewer, three possibilities:
   //       - select TTree context menu item "StartViewer"
   //       - type the command  "TTreeViewer TV(treeName)"
   //       - execute statement "tree->StartViewer();"
   //

   GetPlayer();
   if (fPlayer)
      return fPlayer->DrawSelect(varexp,selection,option,nentries,firstentry);
   return -1;
}

//______________________________________________________________________________
void TTree::DropBaskets()
{
   // Remove some baskets from memory.

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

//______________________________________________________________________________
void TTree::DropBuffers(Int_t)
{
   // Drop branch buffers to accommodate nbytes below MaxVirtualsize.

   // Be careful not to remove current read/write buffers.
   Int_t ndrop = 0;
   Int_t nleaves = fLeaves.GetEntriesFast();
   for (Int_t i = 0; i < nleaves; ++i)  {
      TLeaf* leaf = (TLeaf*) fLeaves.UncheckedAt(i);
      TBranch* branch = (TBranch*) leaf->GetBranch();
      Int_t nbaskets = branch->GetListOfBaskets()->GetEntries();
      for (Int_t j = 0; j < nbaskets - 1; ++j) {
         if ((j == branch->GetReadBasket()) || (j == branch->GetWriteBasket())) {
            continue;
         }
         TBasket* basket = (TBasket*)branch->GetListOfBaskets()->UncheckedAt(j);
         if (basket) {
            ndrop += basket->DropBuffers();
            if (fTotalBuffers < fMaxVirtualSize) {
               return;
            }
         }
      }
   }
}

//______________________________________________________________________________
Int_t TTree::Fill()
{
   // Fill all branches.
   //
   //   This function loops on all the branches of this tree.  For
   //   each branch, it copies to the branch buffer (basket) the current
   //   values of the leaves data types. If a leaf is a simple data type,
   //   a simple conversion to a machine independent format has to be done.
   //
   //   This machine independent version of the data is copied into a
   //   basket (each branch has its own basket).  When a basket is full
   //   (32k worth of data by default), it is then optionally compressed
   //   and written to disk (this operation is also called committing or
   //   'flushing' the basket).  The committed baskets are then
   //   immediately removed from memory.
   //
   //   The function returns the number of bytes committed to the
   //   individual branches.
   //
   //   If a write error occurs, the number of bytes returned is -1.
   //
   //   If no data are written, because, e.g., the branch is disabled,
   //   the number of bytes returned is 0.
   //
   //        The baskets are flushed and the Tree header saved at regular intervals
   //         ---------------------------------------------------------------------
   //   At regular intervals, when the amount of data written so far is
   //   greater than fAutoFlush (see SetAutoFlush) all the baskets are flushed to disk.
   //   This makes future reading faster as it guarantees that baskets belonging to nearby
   //   entries will be on the same disk region.
   //   When the first call to flush the baskets happen, we also take this opportunity
   //   to optimize the baskets buffers.
   //   We also check if the amount of data written is greater than fAutoSave (see SetAutoSave).
   //   In this case we also write the Tree header. This makes the Tree recoverable up to this point
   //   in case the program writing the Tree crashes.
   //   The decisions to FlushBaskets and Auto Save can be made based either on the number
   //   of bytes written (fAutoFlush and fAutoSave negative) or on the number of entries
   //   written (fAutoFlush and fAutoSave positive).
   //   Note that the user can decide to call FlushBaskets and AutoSave in her event loop
   //   base on the number of events written instead of the number of bytes written.
   //
   //   Note that calling FlushBaskets too often increases the IO time.
   //   Note that calling AutoSave too often increases the IO time and also the file size.

   // create cache if wanted
   if (fCacheDoAutoInit) SetCacheSizeAux();

   Int_t nbytes = 0;
   Int_t nerror = 0;
   Int_t nb = fBranches.GetEntriesFast();
   if (nb == 1) {
      // Case of one single super branch. Automatically update
      // all the branch addresses if a new object was created.
      TBranch* branch = (TBranch*) fBranches.UncheckedAt(0);
      branch->UpdateAddress();
   }
   if (fBranchRef) {
      fBranchRef->Clear();
   }
   for (Int_t i = 0; i < nb; ++i) {
      // Loop over all branches, filling and accumulating bytes written and error counts.
      TBranch* branch = (TBranch*) fBranches.UncheckedAt(i);
      if (branch->TestBit(kDoNotProcess)) {
         continue;
      }
      Int_t nwrite = branch->Fill();
      if (nwrite < 0)  {
         if (nerror < 2) {
            Error("Fill", "Failed filling branch:%s.%s, nbytes=%d, entry=%lld\n"
                  " This error is symptomatic of a Tree created as a memory-resident Tree\n"
                  " Instead of doing:\n"
                  "    TTree *T = new TTree(...)\n"
                  "    TFile *f = new TFile(...)\n"
                  " you should do:\n"
                  "    TFile *f = new TFile(...)\n"
                  "    TTree *T = new TTree(...)",
                  GetName(), branch->GetName(), nwrite,fEntries+1);
         } else {
            Error("Fill", "Failed filling branch:%s.%s, nbytes=%d, entry=%lld", GetName(), branch->GetName(), nwrite,fEntries+1);
         }
         ++nerror;
      } else {
         nbytes += nwrite;
      }
   }
   if (fBranchRef) {
      fBranchRef->Fill();
   }
   ++fEntries;
   if (fEntries > fMaxEntries) {
      KeepCircular();
   }
   if (gDebug > 0) printf("TTree::Fill - A:  %d %lld %lld %lld %lld %lld %lld \n",
       nbytes, fEntries, fAutoFlush,fAutoSave,fZipBytes,fFlushedBytes,fSavedBytes);

   if (fAutoFlush != 0 || fAutoSave != 0) {
      // Is it time to flush or autosave baskets?
      if (fFlushedBytes == 0) {
         // Decision can be based initially either on the number of bytes
         // or the number of entries written.
         if ((fAutoFlush<0 && fZipBytes > -fAutoFlush)  ||
             (fAutoSave <0 && fZipBytes > -fAutoSave )  ||
             (fAutoFlush>0 && fEntries%TMath::Max((Long64_t)1,fAutoFlush) == 0) ||
             (fAutoSave >0 && fEntries%TMath::Max((Long64_t)1,fAutoSave)  == 0) ) {

            //First call FlushBasket to make sure that fTotBytes is up to date.
            FlushBaskets();
            OptimizeBaskets(fTotBytes,1,"");
            if (gDebug > 0) Info("TTree::Fill","OptimizeBaskets called at entry %lld, fZipBytes=%lld, fFlushedBytes=%lld\n",fEntries,fZipBytes,fFlushedBytes);
            fFlushedBytes = fZipBytes;
            fAutoFlush    = fEntries;  // Use test on entries rather than bytes

            // subsequently in run
            if (fAutoSave < 0) {
               // Set fAutoSave to the largest integer multiple of
               // fAutoFlush events such that fAutoSave*fFlushedBytes
               // < (minus the input value of fAutoSave)
               if (fZipBytes != 0) {
                  fAutoSave =  TMath::Max( fAutoFlush, fEntries*((-fAutoSave/fZipBytes)/fEntries));
               } else if (fTotBytes != 0) {
                  fAutoSave =  TMath::Max( fAutoFlush, fEntries*((-fAutoSave/fTotBytes)/fEntries));
               } else {
                  TBufferFile b(TBuffer::kWrite, 10000);
                  TTree::Class()->WriteBuffer(b, (TTree*) this);
                  Long64_t total = b.Length();
                  fAutoSave =  TMath::Max( fAutoFlush, fEntries*((-fAutoSave/total)/fEntries));
               }
            } else if(fAutoSave > 0) {
               fAutoSave = fAutoFlush*(fAutoSave/fAutoFlush);
            }
            if (fAutoSave!=0 && fEntries >= fAutoSave) AutoSave();    // FlushBaskets not called in AutoSave
            if (gDebug > 0) Info("TTree::Fill","First AutoFlush.  fAutoFlush = %lld, fAutoSave = %lld\n", fAutoFlush, fAutoSave);
         }
      } else if (fNClusterRange && fAutoFlush && ( (fEntries-fClusterRangeEnd[fNClusterRange-1]) % fAutoFlush == 0)  ) {
         if (fAutoSave != 0 && fEntries%fAutoSave == 0) {
            //We are at an AutoSave point. AutoSave flushes baskets and saves the Tree header
            AutoSave("flushbaskets");
            if (gDebug > 0) Info("TTree::Fill","AutoSave called at entry %lld, fZipBytes=%lld, fSavedBytes=%lld\n",fEntries,fZipBytes,fSavedBytes);
         } else {
            //We only FlushBaskets
            FlushBaskets();
            if (gDebug > 0) Info("TTree::Fill","FlushBasket called at entry %lld, fZipBytes=%lld, fFlushedBytes=%lld\n",fEntries,fZipBytes,fFlushedBytes);
         }
         fFlushedBytes = fZipBytes;
      } else if (fNClusterRange == 0 && fEntries > 1 && fAutoFlush && fEntries%fAutoFlush == 0) {
         if (fAutoSave != 0 && fEntries%fAutoSave == 0) {
            //We are at an AutoSave point. AutoSave flushes baskets and saves the Tree header
            AutoSave("flushbaskets");
            if (gDebug > 0) Info("TTree::Fill","AutoSave called at entry %lld, fZipBytes=%lld, fSavedBytes=%lld\n",fEntries,fZipBytes,fSavedBytes);
         } else {
            //We only FlushBaskets
            FlushBaskets();
            if (gDebug > 0) Info("TTree::Fill","FlushBasket called at entry %lld, fZipBytes=%lld, fFlushedBytes=%lld\n",fEntries,fZipBytes,fFlushedBytes);
         }
         fFlushedBytes = fZipBytes;
      }
   }
   // Check that output file is still below the maximum size.
   // If above, close the current file and continue on a new file.
   // Currently, the automatic change of file is restricted
   // to the case where the tree is in the top level directory.
   if (!fDirectory) {
      return nbytes;
   }
   TFile* file = fDirectory->GetFile();
   if (file && (file->GetEND() > fgMaxTreeSize)) {
      if (fDirectory == (TDirectory*) file) {
         ChangeFile(file);
      }
   }
   if (nerror) {
      return -1;
   }
   return nbytes;
}

//______________________________________________________________________________
static TBranch *R__FindBranchHelper(TObjArray *list, const char *branchname) {
   // Search in the array for a branch matching the branch name,
   // with the branch possibly expressed as a 'full' path name (with dots).

   if (list==0 || branchname == 0 || branchname[0] == '\0') return 0;

   Int_t nbranches = list->GetEntries();

   UInt_t brlen = strlen(branchname);

   for(Int_t index = 0; index < nbranches; ++index) {
      TBranch *where = (TBranch*)list->UncheckedAt(index);

      const char *name = where->GetName();
      UInt_t len = strlen(name);
      if (len && name[len-1]==']') {
         const  char *dim = strchr(name,'[');
         if (dim) {
            len = dim - name;
         }
      }
      if (brlen == len && strncmp(branchname,name,len)==0) {
         return where;
      }
      TBranch *next = 0;
      if ((brlen >= len) && (branchname[len] == '.')
          && strncmp(name, branchname, len) == 0) {
         // The prefix subbranch name match the branch name.

         next = where->FindBranch(branchname);
         if (!next) {
            next = where->FindBranch(branchname+len+1);
         }
         if (next) return next;
      }
      const char *dot = strchr((char*)branchname,'.');
      if (dot) {
         if (len==(size_t)(dot-branchname) &&
             strncmp(branchname,name,dot-branchname)==0 ) {
            return R__FindBranchHelper(where->GetListOfBranches(),dot+1);
         }
      }
   }
   return 0;
}

//______________________________________________________________________________
TBranch* TTree::FindBranch(const char* branchname)
{
   // Return the branch that correspond to the path 'branchname', which can
   // include the name of the tree or the omitted name of the parent branches.
   // In case of ambiguity, returns the first match.

   // We already have been visited while recursively looking
   // through the friends tree, let return
   if (kFindBranch & fFriendLockStatus) {
      return 0;
   }

   TBranch* branch = 0;
   // If the first part of the name match the TTree name, look for the right part in the
   // list of branches.
   // This will allow the branchname to be preceded by
   // the name of this tree.
   if (strncmp(fName.Data(),branchname,fName.Length())==0 && branchname[fName.Length()]=='.') {
      branch = R__FindBranchHelper( GetListOfBranches(), branchname + fName.Length() + 1);
      if (branch) return branch;
   }
   // If we did not find it, let's try to find the full name in the list of branches.
   branch = R__FindBranchHelper(GetListOfBranches(), branchname);
   if (branch) return branch;

   // If we still did not find, let's try to find it within each branch assuming it does not the branch name.
   TIter next(GetListOfBranches());
   while ((branch = (TBranch*) next())) {
      TBranch* nestedbranch = branch->FindBranch(branchname);
      if (nestedbranch) {
         return nestedbranch;
      }
   }

   // Search in list of friends.
   if (!fFriends) {
      return 0;
   }
   TFriendLock lock(this, kFindBranch);
   TIter nextf(fFriends);
   TFriendElement* fe = 0;
   while ((fe = (TFriendElement*) nextf())) {
      TTree* t = fe->GetTree();
      if (!t) {
         continue;
      }
      // If the alias is present replace it with the real name.
      const char *subbranch = strstr(branchname, fe->GetName());
      if (subbranch != branchname) {
         subbranch = 0;
      }
      if (subbranch) {
         subbranch += strlen(fe->GetName());
         if (*subbranch != '.') {
            subbranch = 0;
         } else {
            ++subbranch;
         }
      }
      std::ostringstream name;
      if (subbranch) {
         name << t->GetName() << "." << subbranch;
      } else {
         name << branchname;
      }
      branch = t->FindBranch(name.str().c_str());
      if (branch) {
         return branch;
      }
   }
   return 0;
}

//______________________________________________________________________________
TLeaf* TTree::FindLeaf(const char* searchname)
{
   // FIXME: Describe this function.

   // We already have been visited while recursively looking
   // through the friends tree, let's return.
   if (kFindLeaf & fFriendLockStatus) {
      return 0;
   }

   // This will allow the branchname to be preceded by
   // the name of this tree.
   char* subsearchname = (char*) strstr(searchname, GetName());
   if (subsearchname != searchname) {
      subsearchname = 0;
   }
   if (subsearchname) {
      subsearchname += strlen(GetName());
      if (*subsearchname != '.') {
         subsearchname = 0;
      } else {
         ++subsearchname;
         if (subsearchname[0]==0) {
            subsearchname = 0;
         }
      }
   }

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

   // For leaves we allow for one level up to be prefixed to 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;
      }
      if (subsearchname && leafname == subsearchname) {
         return leaf;
      }
      // The TLeafElement 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;
      }
      if (subsearchname && leaftitle == subsearchname) {
         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;
         }
         if (subsearchname && longname == subsearchname) {
            return leaf;
         }
         longtitle.Form("%s.%s",branch->GetName(),leaftitle.Data());
         dim = longtitle.First('[');
         if (dim>=0) longtitle.Remove(dim);
         if (longtitle == searchname) {
            return leaf;
         }
         if (subsearchname && longtitle == subsearchname) {
            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;
         }
         if (subsearchname && strstr(subsearchname, ".") && !strcmp(subsearchname, branch->GetName())) {
            return leaf;
         }
      }
   }
   // Search in list of friends.
   if (!fFriends) {
      return 0;
   }
   TFriendLock lock(this, kFindLeaf);
   TIter nextf(fFriends);
   TFriendElement* fe = 0;
   while ((fe = (TFriendElement*) nextf())) {
      TTree* t = fe->GetTree();
      if (!t) {
         continue;
      }
      // If the alias is present replace it with the real name.
      subsearchname = (char*) strstr(searchname, fe->GetName());
      if (subsearchname != searchname) {
         subsearchname = 0;
      }
      if (subsearchname) {
         subsearchname += strlen(fe->GetName());
         if (*subsearchname != '.') {
            subsearchname = 0;
         } else {
            ++subsearchname;
         }
      }
      if (subsearchname) {
         leafname.Form("%s.%s",t->GetName(),subsearchname);
      } else {
         leafname = searchname;
      }
      leaf = t->FindLeaf(leafname);
      if (leaf) {
         return leaf;
      }
   }
   return 0;
}

//______________________________________________________________________________
Int_t TTree::Fit(const char* funcname, const char* varexp, const char* selection, Option_t* option, Option_t* goption, Long64_t nentries, Long64_t firstentry)
{
   // Fit  a projected item(s) from a tree.
   //
   //  funcname is a TF1 function.
   //
   //  See TTree::Draw() for explanations of the other parameters.
   //
   //  By default the temporary histogram created is called htemp.
   //  If varexp contains >>hnew , the new histogram created is called hnew
   //  and it is kept in the current directory.
   //
   //  The function returns the number of selected entries.
   //
   //  Example:
   //    tree.Fit(pol4,sqrt(x)>>hsqrt,y>0)
   //    will fit sqrt(x) and save the histogram as "hsqrt" in the current
   //    directory.
   //
   //   See also TTree::UnbinnedFit
   //
   //   Return status
   //   =============
   //  The function returns the status of the histogram fit (see TH1::Fit)
   //  If no entries were selected, the function returns -1;
   //   (i.e. fitResult is null is the fit is OK)

   GetPlayer();
   if (fPlayer) {
      return fPlayer->Fit(funcname, varexp, selection, option, goption, nentries, firstentry);
   }
   return -1;
}

//______________________________________________________________________________
Int_t TTree::FlushBaskets() const
{
   // Write to disk all the basket that have not yet been individually written.
   //
   // Return the number of bytes written or -1 in case of write error.

   if (!fDirectory) return 0;
   Int_t nbytes = 0;
   Int_t nerror = 0;
   TObjArray *lb = const_cast<TTree*>(this)->GetListOfBranches();
   Int_t nb = lb->GetEntriesFast();
   for (Int_t j = 0; j < nb; j++) {
      TBranch* branch = (TBranch*) lb->UncheckedAt(j);
      if (branch) {
         Int_t nwrite = branch->FlushBaskets();
         if (nwrite<0) {
            ++nerror;
         } else {
            nbytes += nwrite;
         }
      }
   }
   if (nerror) {
      return -1;
   } else {
      return nbytes;
   }
}

//______________________________________________________________________________
const char* TTree::GetAlias(const char* aliasName) const
{
   // Returns the expanded value of the alias.  Search in the friends if any.

   // We already have been visited while recursively looking
   // through the friends tree, let's return.
   if (kGetAlias & fFriendLockStatus) {
      return 0;
   }
   if (fAliases) {
      TObject* alias = fAliases->FindObject(aliasName);
      if (alias) {
         return alias->GetTitle();
      }
   }
   if (!fFriends) {
      return 0;
   }
   TFriendLock lock(const_cast<TTree*>(this), kGetAlias);
   TIter nextf(fFriends);
   TFriendElement* fe = 0;
   while ((fe = (TFriendElement*) nextf())) {
      TTree* t = fe->GetTree();
      if (t) {
         const char* alias = t->GetAlias(aliasName);
         if (alias) {
            return alias;
         }
         const char* subAliasName = strstr(aliasName, fe->GetName());
         if (subAliasName && (subAliasName[strlen(fe->GetName())] == '.')) {
            alias = t->GetAlias(aliasName + strlen(fe->GetName()) + 1);
            if (alias) {
               return alias;
            }
         }
      }
   }
   return 0;
}

//______________________________________________________________________________
TBranch* TTree::GetBranch(const char* name)
{
   // Return pointer to the branch with the given name in this tree or its friends.

   if (name == 0) return 0;

   // We already have been visited while recursively
   // looking through the friends tree, let's return.
   if (kGetBranch & fFriendLockStatus) {
      return 0;
   }

   // Search using branches.
   Int_t nb = fBranches.GetEntriesFast();
   for (Int_t i = 0; i < nb; i++) {
      TBranch* branch = (TBranch*) fBranches.UncheckedAt(i);
      if (!strcmp(branch->GetName(), name)) {
         return branch;
      }
      TObjArray* lb = branch->GetListOfBranches();
      Int_t nb1 = lb->GetEntriesFast();
      for (Int_t j = 0; j < nb1; j++) {
         TBranch* b1 = (TBranch*) lb->UncheckedAt(j);
         if (!strcmp(b1->GetName(), name)) {
            return b1;
         }
         TObjArray* lb1 = b1->GetListOfBranches();
         Int_t nb2 = lb1->GetEntriesFast();
         for (Int_t k = 0; k < nb2; k++) {
            TBranch* b2 = (TBranch*) lb1->UncheckedAt(k);
            if (!strcmp(b2->GetName(), name)) {
               return b2;
            }
         }
      }
   }

   // Search using leaves.
   TObjArray* leaves = GetListOfLeaves();
   Int_t nleaves = leaves->GetEntriesFast();
   for (Int_t i = 0; i < nleaves; i++) {
      TLeaf* leaf = (TLeaf*) leaves->UncheckedAt(i);
      TBranch* branch = leaf->GetBranch();
      if (!strcmp(branch->GetName(), name)) {
         return branch;
      }
   }

   if (!fFriends) {
      return 0;
   }

   // Search in list of friends.
   TFriendLock lock(this, kGetBranch);
   TIter next(fFriends);
   TFriendElement* fe = 0;
   while ((fe = (TFriendElement*) next())) {
      TTree* t = fe->GetTree();
      if (t) {
         TBranch* branch = t->GetBranch(name);
         if (branch) {
            return branch;
         }
      }
   }

   // Second pass in the list of friends when
   // the branch name is prefixed by the tree name.
   next.Reset();
   while ((fe = (TFriendElement*) next())) {
      TTree* t = fe->GetTree();
      if (!t) {
         continue;
      }
      char* subname = (char*) strstr(name, fe->GetName());
      if (subname != name) {
         continue;
      }
      Int_t l = strlen(fe->GetName());
      subname += l;
      if (*subname != '.') {
         continue;
      }
      subname++;
      TBranch* branch = t->GetBranch(subname);
      if (branch) {
         return branch;
      }
   }
   return 0;
}

//______________________________________________________________________________
Bool_t TTree::GetBranchStatus(const char* branchname) const
{
   // Return status of branch with name branchname.
   // 0 if branch is not activated
   // 1 if branch is activated

   TBranch* br = const_cast<TTree*>(this)->GetBranch(branchname);
   if (br) {
      return br->TestBit(kDoNotProcess) == 0;
   }
   return 0;
}

//______________________________________________________________________________
Int_t TTree::GetBranchStyle()
{
   // Static function returning the current branch style.
   // style = 0 old Branch
   // style = 1 new Bronch

   return fgBranchStyle;
}

//______________________________________________________________________________
Long64_t TTree::GetCacheAutoSize(Bool_t withDefault /* = kFALSE */ ) const
{
   // Used for automatic sizing of the cache.
   // Estimates a suitable size for the tree cache based on AutoFlush.
   // A cache sizing factor is taken from the configuration. If this yields zero
   // and withDefault is true the historical algoirthm for default size is used.

   const char *stcs;
   Double_t cacheFactor = 0.0;
   if (!(stcs = gSystem->Getenv("ROOT_TTREECACHE_SIZE")) || !*stcs) {
      cacheFactor = gEnv->GetValue("TTreeCache.Size", 1.0);
   } else {
      cacheFactor = TString(stcs).Atof();
   }

   if (cacheFactor < 0.0) {
     // ignore negative factors
     cacheFactor = 0.0;
   }

   Long64_t cacheSize = 0;

   if (fAutoFlush < 0) cacheSize = Long64_t(-cacheFactor*fAutoFlush);
   else if (fAutoFlush == 0) cacheSize = 0;
   else cacheSize = Long64_t(cacheFactor*1.5*fAutoFlush*fZipBytes/(fEntries+1));

   if (cacheSize >= (INT_MAX / 4)) {
      cacheSize = INT_MAX / 4;
   }

   if (cacheSize < 0) {
      cacheSize = 0;
   }

   if (cacheSize == 0 && withDefault) {
      if (fAutoFlush < 0) cacheSize = -fAutoFlush;
      else if (fAutoFlush == 0) cacheSize = 0;
      else cacheSize = Long64_t(1.5*fAutoFlush*fZipBytes/(fEntries+1));
   }

   return cacheSize;
}

//______________________________________________________________________________
TTree::TClusterIterator TTree::GetClusterIterator(Long64_t firstentry)
{
   // Return an iterator over the cluster of baskets starting at firstentry.
   //
   // This iterator is not yet supported for TChain object.
   //
   // TTree::TClusterIterator clusterIter = tree->GetClusterIterator(entry);
   // Long64_t clusterStart;
   // while( (clusterStart = clusterIter()) < tree->GetEntries() ) {
   //    printf("The cluster starts at %lld and ends at %lld (inclusive)\n",clusterStart,clusterIter.GetNextEntry()-1);
   // }

   // create cache if wanted
   if (fCacheDoAutoInit) SetCacheSizeAux();

   return TClusterIterator(this,firstentry);
}

//______________________________________________________________________________
TFile* TTree::GetCurrentFile() const
{
   // Return pointer to the current file.

   if (!fDirectory || fDirectory==gROOT) {
      return 0;
   }
   return fDirectory->GetFile();
}

//______________________________________________________________________________
Long64_t TTree::GetEntries(const char *selection)
{
   // Return the number of entries matching the selection.
   // Return -1 in case of errors.
   //
   // If the selection uses any arrays or containers, we return the number
   // of entries where at least one element match the selection.
   // GetEntries is implemented using the selector class TSelectorEntries,
   // which can be used directly (see code in TTreePlayer::GetEntries) for
   // additional option.
   // If SetEventList was used on the TTree or TChain, only that subset
   // of entries will be considered.

   GetPlayer();
   if (fPlayer) {
      return fPlayer->GetEntries(selection);
   }
   return -1;
}

//______________________________________________________________________________
Long64_t TTree::GetEntriesFriend() const
{
   // Return pointer to the 1st Leaf named name in any Branch of this Tree or
   // any branch in the list of friend trees.

   if (fEntries) return fEntries;
   if (!fFriends) return 0;
   TFriendElement *fr = (TFriendElement*)fFriends->At(0);
   if (!fr) return 0;
   TTree *t = fr->GetTree();
   if (t==0) return 0;
   return t->GetEntriesFriend();
}

//______________________________________________________________________________
Int_t TTree::GetEntry(Long64_t entry, Int_t getall)
{
   // Read all branches of entry and return total number of bytes read.
   //
   //     getall = 0 : get only active branches
   //     getall = 1 : get all branches
   //
   //  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.
   //
   //  If the Tree has friends, also read the friends entry.
   //
   //  To activate/deactivate one or more branches, use TBranch::SetBranchStatus
   //  For example, if you have a Tree with several hundred branches, and you
   //  are interested only by branches named "a" and "b", do
   //     mytree.SetBranchStatus("*",0); //disable all branches
   //     mytree.SetBranchStatus("a",1);
   //     mytree.SetBranchStatus("b",1);
   //  when calling mytree.GetEntry(i); only branches "a" and "b" will be read.
   //
   //  WARNING!!
   //  If your Tree has been created in split mode with a parent branch "parent.",
   //     mytree.SetBranchStatus("parent",1);
   //  will not activate the sub-branches of "parent". You should do:
   //     mytree.SetBranchStatus("parent*",1);
   //
   //  Without the trailing dot in the branch creation you have no choice but to
   //  call SetBranchStatus explicitly for each of the sub branches.
   //
   //  An alternative is to call directly
   //     brancha.GetEntry(i)
   //     branchb.GetEntry(i);
   //
   //  IMPORTANT NOTE
   //  ==============
   // By default, GetEntry reuses the space allocated by the previous object
   // for each branch. You can force the previous object to be automatically
   // deleted if you call mybranch.SetAutoDelete(kTRUE) (default is kFALSE).
   // Example:
   // Consider the example in $ROOTSYS/test/Event.h
   // The top level branch in the tree T is declared with:
   //    Event *event = 0;  //event must be null or point to a valid object
   //                       //it must be initialized
   //    T.SetBranchAddress("event",&event);
   // When reading the Tree, one can choose one of these 3 options:
   //
   //   OPTION 1
   //   --------
   //
   //    for (Long64_t i=0;i<nentries;i++) {
   //       T.GetEntry(i);
   //       // the object event has been filled at this point
   //    }
   //   The default (recommended). At the first entry an object of the class
   //   Event will be created and pointed by event. At the following entries,
   //   event will be overwritten by the new data. All internal members that are
   //   TObject* are automatically deleted. It is important that these members
   //   be in a valid state when GetEntry is called. Pointers must be correctly
   //   initialized. However these internal members will not be deleted if the
   //   characters "->" are specified as the first characters in the comment
   //   field of the data member declaration.
   //
   //   If "->" is specified, the pointer member is read via pointer->Streamer(buf).
   //   In this case, it is assumed that the pointer is never null (case of
   //   pointer TClonesArray *fTracks in the Event example). If "->" is not
   //   specified, the pointer member is read via buf >> pointer. In this case
   //   the pointer may be null. Note that the option with "->" is faster to
   //   read or write and it also consumes less space in the file.
   //
   //   OPTION 2
   //   --------
   //  The option AutoDelete is set
   //   TBranch *branch = T.GetBranch("event");
   //   branch->SetAddress(&event);
   //   branch->SetAutoDelete(kTRUE);
   //    for (Long64_t i=0;i<nentries;i++) {
   //       T.GetEntry(i);
   //       // the object event has been filled at this point
   //    }
   //   In this case, at each iteration, the object event is deleted by GetEntry
   //   and a new instance of Event is created and filled.
   //
   //   OPTION 3
   //   --------
   //   Same as option 1, but you delete yourself the event.
   //    for (Long64_t i=0;i<nentries;i++) {
   //       delete event;
   //       event = 0;  // EXTREMELY IMPORTANT
   //       T.GetEntry(i);
   //       // the object event has been filled at this point
   //    }
   //
   //  It is strongly recommended to use the default option 1. It has the
   //  additional advantage that functions like TTree::Draw (internally calling
   //  TTree::GetEntry) will be functional even when the classes in the file are
   //  not available.
   //
   //  Note: See the comments in TBranchElement::SetAddress() for the
   //    object ownership policy of the underlying (user) data.


   // We already have been visited while recursively looking
   // through the friends tree, let return
   if (kGetEntry & fFriendLockStatus) return 0;

   if (entry < 0 || entry >= fEntries) return 0;
   Int_t i;
   Int_t nbytes = 0;
   fReadEntry = entry;
   TBranch *branch;

   // create cache if wanted
   if (fCacheDoAutoInit) SetCacheSizeAux();

   Int_t nbranches = fBranches.GetEntriesFast();
   Int_t nb=0;
   for (i=0;i<nbranches;i++)  {
      branch = (TBranch*)fBranches.UncheckedAt(i);
      nb = branch->GetEntry(entry, getall);
      if (nb < 0) return nb;
      nbytes += nb;
   }

   // GetEntry in list of friends
   if (!fFriends) return nbytes;
   TFriendLock lock(this,kGetEntry);
   TIter nextf(fFriends);
   TFriendElement *fe;
   while ((fe = (TFriendElement*)nextf())) {
      TTree *t = fe->GetTree();
      if (t) {
         if (fe->TestBit(TFriendElement::kFromChain)) {
            nb = t->GetEntry(t->GetReadEntry(),getall);
         } else {
            if ( t->LoadTreeFriend(entry,this) >= 0 ) {
               nb = t->GetEntry(t->GetReadEntry(),getall);
            } else nb = 0;
         }
         if (nb < 0) return nb;
         nbytes += nb;
      }
   }
   return nbytes;
}

//______________________________________________________________________________
TEntryList* TTree::GetEntryList()
{
//Returns the entry list, set to this tree

   return fEntryList;
}

//______________________________________________________________________________
Long64_t TTree::GetEntryNumber(Long64_t entry) const
{
   // Return entry number corresponding to entry.
   //
   // if no TEntryList set returns entry
   // else returns the entry number corresponding to the list index=entry

   if (!fEntryList) {
      return entry;
   }

   return fEntryList->GetEntry(entry);
}

//______________________________________________________________________________
Long64_t TTree::GetEntryNumberWithBestIndex(Long64_t major, Long64_t minor) const
{
   // Return entry number corresponding to major and minor number.
   // Note that this function returns only the entry number, not the data
   // To read the data corresponding to an entry number, use TTree::GetEntryWithIndex
   // the BuildIndex function has created a table of Long64_t* of sorted values
   // corresponding to val = major<<31 + minor;
   // The function performs binary search in this sorted table.
   // If it finds a pair that maches val, it returns directly the
   // index in the table.
   // If an entry corresponding to major and minor is not found, the function
   // returns the index of the major,minor pair immediately lower than the
   // requested value, ie it will return -1 if the pair is lower than
   // the first entry in the index.
   //
   // See also GetEntryNumberWithIndex

   if (!fTreeIndex) {
      return -1;
   }
   return fTreeIndex->GetEntryNumberWithBestIndex(major, minor);
}

//______________________________________________________________________________
Long64_t TTree::GetEntryNumberWithIndex(Long64_t major, Long64_t minor) const
{
   // Return entry number corresponding to major and minor number.
   // Note that this function returns only the entry number, not the data
   // To read the data corresponding to an entry number, use TTree::GetEntryWithIndex
   // the BuildIndex function has created a table of Long64_t* of sorted values
   // corresponding to val = major<<31 + minor;
   // The function performs binary search in this sorted table.
   // If it finds a pair that maches val, it returns directly the
   // index in the table, otherwise it returns -1.
   //
   // See also GetEntryNumberWithBestIndex

   if (!fTreeIndex) {
      return -1;
   }
   return fTreeIndex->GetEntryNumberWithIndex(major, minor);
}

//______________________________________________________________________________
Int_t TTree::GetEntryWithIndex(Int_t major, Int_t minor)
{
   // Read entry corresponding to major and minor number.
   //
   //  The function returns the total number of bytes read.
   //  If the Tree has friend trees, the corresponding entry with
   //  the index values (major,minor) is read. Note that the master Tree
   //  and its friend may have different entry serial numbers corresponding
   //  to (major,minor).

   // We already have been visited while recursively looking
   // through the friends tree, let's return.
   if (kGetEntryWithIndex & fFriendLockStatus) {
      return 0;
   }
   Long64_t serial = GetEntryNumberWithIndex(major, minor);
   if (serial < 0) {
      return -1;
   }
   // create cache if wanted
   if (fCacheDoAutoInit) SetCacheSizeAux();

   Int_t i;
   Int_t nbytes = 0;
   fReadEntry = serial;
   TBranch *branch;
   Int_t nbranches = fBranches.GetEntriesFast();
   Int_t nb;
   for (i = 0; i < nbranches; ++i) {
      branch = (TBranch*)fBranches.UncheckedAt(i);
      nb = branch->GetEntry(serial);
      if (nb < 0) return nb;
      nbytes += nb;
   }
   // GetEntry in list of friends
   if (!fFriends) return nbytes;
   TFriendLock lock(this,kGetEntryWithIndex);
   TIter nextf(fFriends);
   TFriendElement* fe = 0;
   while ((fe = (TFriendElement*) nextf())) {
      TTree *t = fe->GetTree();
      if (t) {
         serial = t->GetEntryNumberWithIndex(major,minor);
         if (serial <0) return -nbytes;
         nb = t->GetEntry(serial);
         if (nb < 0) return nb;
         nbytes += nb;
      }
   }
   return nbytes;
}
//______________________________________________________________________________
TTree* TTree::GetFriend(const char *friendname) const
{
   // Return a pointer to the TTree friend whose name or alias is 'friendname.


   // We already have been visited while recursively
   // looking through the friends tree, let's return.
   if (kGetFriend & fFriendLockStatus) {
      return 0;
   }
   if (!fFriends) {
      return 0;
   }
   TFriendLock lock(const_cast<TTree*>(this), kGetFriend);
   TIter nextf(fFriends);
   TFriendElement* fe = 0;
   while ((fe = (TFriendElement*) nextf())) {
      if (strcmp(friendname,fe->GetName())==0
          || strcmp(friendname,fe->GetTreeName())==0) {
         return fe->GetTree();
      }
   }
   // After looking at the first level,
   // let's see if it is a friend of friends.
   nextf.Reset();
   fe = 0;
   while ((fe = (TFriendElement*) nextf())) {
      TTree *res = fe->GetTree()->GetFriend(friendname);
      if (res) {
         return res;
      }
   }
   return 0;
}

//______________________________________________________________________________
const char* TTree::GetFriendAlias(TTree* tree) const
{
   // If the 'tree' is a friend, this method returns its alias name.
   //
   // This alias is an alternate name for the tree.
   //
   // It can be used in conjunction with a branch or leaf name in a TTreeFormula,
   // to specify in which particular tree the branch or leaf can be found if
   // the friend trees have branches or leaves with the same name as the master
   // tree.
   //
   // It can also be used in conjunction with an alias created using
   // TTree::SetAlias in a TTreeFormula, e.g.:
   //
   //      maintree->Draw("treealias.fPx - treealias.myAlias");
   //
   // where fPx is a branch of the friend tree aliased as 'treealias' and 'myAlias'
   // was created using TTree::SetAlias on the friend tree.
   //
   // However, note that 'treealias.myAlias' will be expanded literally,
   // without remembering that it comes from the aliased friend and thus
   // the branch name might not be disambiguated properly, which means
   // that you may not be able to take advantage of this feature.
   //

   if ((tree == this) || (tree == GetTree())) {
      return 0;
   }

   // We already have been visited while recursively
   // looking through the friends tree, let's return.
   if (kGetFriendAlias & fFriendLockStatus) {
      return 0;
   }
   if (!fFriends) {
      return 0;
   }
   TFriendLock lock(const_cast<TTree*>(this), kGetFriendAlias);
   TIter nextf(fFriends);
   TFriendElement* fe = 0;
   while ((fe = (TFriendElement*) nextf())) {
      TTree* t = fe->GetTree();
      if (t == tree) {
         return fe->GetName();
      }
      // Case of a chain:
      if (t->GetTree() == tree) {
         return fe->GetName();
      }
   }
   // After looking at the first level,
   // let's see if it is a friend of friends.
   nextf.Reset();
   fe = 0;
   while ((fe = (TFriendElement*) nextf())) {
      const char* res = fe->GetTree()->GetFriendAlias(tree);
      if (res) {
         return res;
      }
   }
   return 0;
}

//______________________________________________________________________________
TIterator* TTree::GetIteratorOnAllLeaves(Bool_t dir)
{
   // Creates a new iterator that will go through all the leaves on the tree itself and its friend.

   return new TTreeFriendLeafIter(this, dir);
}

//______________________________________________________________________________
TLeaf* TTree::GetLeafImpl(const char* branchname, const char *leafname)
{
   // Return pointer to the 1st Leaf named name in any Branch of this
   // Tree or any branch in the list of friend trees.
   //
   // The leaf name can contain the name of a friend tree with the
   // syntax: friend_dir_and_tree.full_leaf_name
   // the friend_dir_and_tree can be of the form
   //    TDirectoryName/TreeName

   TLeaf *leaf = 0;
   if (branchname) {
      TBranch *branch = FindBranch(branchname);
      if (branch) {
         leaf = branch->GetLeaf(leafname);
         if (leaf) {
            return leaf;
         }
      }
   }
   TIter nextl(GetListOfLeaves());
   while ((leaf = (TLeaf*)nextl())) {
      if (strcmp(leaf->GetName(),leafname)) continue;
      if (branchname) {
         UInt_t nbch = strlen(branchname);
         TBranch *br = leaf->GetBranch();
         const char* brname = br->GetName();
         TBranch *mother = br->GetMother();
         if (strncmp(brname,branchname,nbch)) {
            if (mother != br) {
               const char *mothername = mother->GetName();
               UInt_t motherlen = strlen(mothername);
               if (nbch > motherlen && strncmp(mothername,branchname,motherlen)==0 && (mothername[motherlen-1]=='.' || branchname[motherlen]=='.')) {
                  // The left part of the requested name match the name of the mother, let's see if the right part match the name of the branch.
                  if (strncmp(brname,branchname+motherlen+1,nbch-motherlen-1)) {
                     // No it does not
                     continue;
                  } // else we have match so we can proceed.
               } else {
                  // no match
                  continue;
               }
            } else {
               continue;
            }
         }
         // The start of the branch name is identical to the content
         // of 'aname' before the first '/'.
         // Let's make sure that it is not longer (we are trying
         // to avoid having jet2/value match the branch jet23
         if ((strlen(brname) > nbch) && (brname[nbch] != '.') && (brname[nbch] != '[')) {
            continue;
         }
      }
      return leaf;
   }
   if (!fFriends) return 0;
   TFriendLock lock(this,kGetLeaf);
   TIter next(fFriends);
   TFriendElement *fe;
   while ((fe = (TFriendElement*)next())) {
      TTree *t = fe->GetTree();
      if (t) {
         leaf = t->GetLeaf(leafname);
         if (leaf) return leaf;
      }
   }

   //second pass in the list of friends when the leaf name
   //is prefixed by the tree name
   TString strippedArg;
   next.Reset();
   while ((fe = (TFriendElement*)next())) {
      TTree *t = fe->GetTree();
      if (t==0) continue;
      char *subname = (char*)strstr(leafname,fe->GetName());
      if (subname != leafname) continue;
      Int_t l = strlen(fe->GetName());
      subname += l;
      if (*subname != '.') continue;
      subname++;
      strippedArg += subname;
      leaf = t->GetLeaf(branchname,subname);
      if (leaf) return leaf;
   }
   return 0;
}

//______________________________________________________________________________
TLeaf* TTree::GetLeaf(const char* branchname, const char *leafname)
{
   // Return pointer to the 1st Leaf named name in any Branch of this
   // Tree or any branch in the list of friend trees.
   //
   // The leaf name can contain the name of a friend tree with the
   // syntax: friend_dir_and_tree.full_leaf_name
   // the friend_dir_and_tree can be of the form
   //    TDirectoryName/TreeName

   if (leafname == 0) return 0;

   // We already have been visited while recursively looking
   // through the friends tree, let return
   if (kGetLeaf & fFriendLockStatus) {
      return 0;
   }

   return GetLeafImpl(branchname,leafname);
}

//______________________________________________________________________________
TLeaf* TTree::GetLeaf(const char* aname)
{
   // Return pointer to the 1st Leaf named name in any Branch of this
   // Tree or any branch in the list of friend trees.
   //
   // aname may be of the form branchname/leafname

   if (aname == 0) return 0;

   // We already have been visited while recursively looking
   // through the friends tree, let return
   if (kGetLeaf & fFriendLockStatus) {
      return 0;
   }
   char* slash = (char*) strrchr(aname, '/');
   char* name = 0;
   UInt_t nbch = 0;
   if (slash) {
      name = slash + 1;
      nbch = slash - aname;
      TString brname(aname,nbch);
      return GetLeafImpl(brname.Data(),name);
   } else {
      return GetLeafImpl(0,aname);
   }
}

//______________________________________________________________________________
Double_t TTree::GetMaximum(const char* columname)
{
   // Return maximum of column with name columname.
   // if the Tree has an associated TEventList or TEntryList, the maximum
   // is computed for the entries in this list.

   TLeaf* leaf = this->GetLeaf(columname);
   if (!leaf) {
      return 0;
   }

   // create cache if wanted
   if (fCacheDoAutoInit) SetCacheSizeAux();

   TBranch* branch = leaf->GetBranch();
   Double_t cmax = -DBL_MAX;
   for (Long64_t i = 0; i < fEntries; ++i) {
      Long64_t entryNumber = this->GetEntryNumber(i);
      if (entryNumber < 0) break;
      branch->GetEntry(entryNumber);
      for (Int_t j = 0; j < leaf->GetLen(); ++j) {
         Double_t val = leaf->GetValue(j);
         if (val > cmax) {
            cmax = val;
         }
      }
   }
   return cmax;
}

//______________________________________________________________________________
Long64_t TTree::GetMaxTreeSize()
{
   // Static function which returns the tree file size limit in bytes.

   return fgMaxTreeSize;
}

//______________________________________________________________________________
Double_t TTree::GetMinimum(const char* columname)
{
   // Return minimum of column with name columname.
   // if the Tree has an associated TEventList or TEntryList, the minimum
   // is computed for the entries in this list.

   TLeaf* leaf = this->GetLeaf(columname);
   if (!leaf) {
      return 0;
   }

   // create cache if wanted
   if (fCacheDoAutoInit) SetCacheSizeAux();

   TBranch* branch = leaf->GetBranch();
   Double_t cmin = DBL_MAX;
   for (Long64_t i = 0; i < fEntries; ++i) {
      Long64_t entryNumber = this->GetEntryNumber(i);
      if (entryNumber < 0) break;
      branch->GetEntry(entryNumber);
      for (Int_t j = 0;j < leaf->GetLen(); ++j) {
         Double_t val = leaf->GetValue(j);
         if (val < cmin) {
            cmin = val;
         }
      }
   }
   return cmin;
}

//______________________________________________________________________________
TVirtualTreePlayer* TTree::GetPlayer()
{
   // Load the TTreePlayer (if not already done).

   if (fPlayer) {
      return fPlayer;
   }
   fPlayer = TVirtualTreePlayer::TreePlayer(this);
   return fPlayer;
}

//______________________________________________________________________________
TTreeCache *TTree::GetReadCache(TFile *file, Bool_t create /* = kFALSE */ )
{
   // Find and return the TTreeCache registered with the file and which may
   // contain branches for us. If create is true and there is no cache
   // a new cache is created with default size.

   TTreeCache *pe = dynamic_cast<TTreeCache*>(file->GetCacheRead(this));
   if (pe && pe->GetTree() != this) pe = 0;
   if (create && !pe) {
      if (fCacheDoAutoInit) SetCacheSizeAux(kTRUE, -1);
      pe = dynamic_cast<TTreeCache*>(file->GetCacheRead(this));
      if (pe && pe->GetTree() != this) pe = 0;
   }
   return pe;
}

//______________________________________________________________________________
TList* TTree::GetUserInfo()
{
   // Return a pointer to the list containing user objects associated to this tree.
   //
   // The list is automatically created if it does not exist.
   //
   // WARNING: By default the TTree destructor will delete all objects added
   //          to this list. If you do not want these objects to be deleted,
   //          call:
   //
   //               mytree->GetUserInfo()->Clear();
   //
   //          before deleting the tree.

   if (!fUserInfo) {
      fUserInfo = new TList();
      fUserInfo->SetName("UserInfo");
   }
   return fUserInfo;
}

//______________________________________________________________________________
void TTree::ImportClusterRanges(TTree *fromtree)
{
   // Appends the cluster range information stored in 'fromtree' to this tree,
   // including the value of fAutoFlush.
   //
   // This is used when doing a fast cloning (by TTreeCloner).
   // See also fAutoFlush and fAutoSave if needed.

   Long64_t autoflush = fromtree->GetAutoFlush();
   if (fNClusterRange || fromtree->fNClusterRange) {
      Int_t newsize = fNClusterRange + 1 + fromtree->fNClusterRange;
      if (newsize > fMaxClusterRange) {
         if (fMaxClusterRange) {
            fClusterRangeEnd = (Long64_t*)TStorage::ReAlloc(fClusterRangeEnd,
                                                            newsize*sizeof(Long64_t),fMaxClusterRange*sizeof(Long64_t));
            fClusterSize = (Long64_t*)TStorage::ReAlloc(fClusterSize,
                                                        newsize*sizeof(Long64_t),fMaxClusterRange*sizeof(Long64_t));
            fMaxClusterRange = newsize;
         } else {
            fMaxClusterRange = newsize;
            fClusterRangeEnd = new Long64_t[fMaxClusterRange];
            fClusterSize = new Long64_t[fMaxClusterRange];
         }
      }
      fClusterRangeEnd[fNClusterRange] = fEntries - 1;
      fClusterSize[fNClusterRange] = fAutoFlush<0 ? 0 : fAutoFlush;
      ++fNClusterRange;
      for (Int_t i = 0 ; i < fromtree->fNClusterRange; ++i) {
         fClusterRangeEnd[fNClusterRange] = fEntries + fromtree->fClusterRangeEnd[i];
         fClusterSize[fNClusterRange] = fromtree->fClusterSize[i];
         ++fNClusterRange;
      }
      fAutoFlush = autoflush;
   } else {
      SetAutoFlush( autoflush );
   }
   Long64_t autosave = GetAutoSave();
   if (autoflush > 0 && autosave > 0) {
      SetAutoSave( autoflush*(autosave/autoflush) );
   }
}

//______________________________________________________________________________
void TTree::KeepCircular()
{
   // Keep a maximum of fMaxEntries in memory.

   Int_t nb = fBranches.GetEntriesFast();
   Long64_t maxEntries = fMaxEntries - (fMaxEntries / 10);
   for (Int_t i = 0; i < nb; ++i)  {
      TBranch* branch = (TBranch*) fBranches.UncheckedAt(i);
      branch->KeepCircular(maxEntries);
   }
   if (fNClusterRange) {
      Long64_t entriesOffset = fEntries - maxEntries;
      Int_t oldsize = fNClusterRange;
      for(Int_t i = 0, j = 0; j < oldsize; ++j) {
         if (fClusterRangeEnd[j] > entriesOffset) {
            fClusterRangeEnd[i] =  fClusterRangeEnd[j] - entriesOffset;
            ++i;
         } else {
            --fNClusterRange;
         }
      }
   }
   fEntries = maxEntries;
   fReadEntry = -1;
}

//______________________________________________________________________________
Int_t TTree::LoadBaskets(Long64_t maxmemory)
{
   // Read in memory all baskets from all branches up to the limit of maxmemory bytes.
   //
   // If maxmemory is non null and positive SetMaxVirtualSize is called
   // with this value. Default for maxmemory is 2000000000 (2 Gigabytes).
   // The function returns the total number of baskets read into memory
   // if negative an error occurred while loading the branches.
   // This method may be called to force branch baskets in memory
   // when random access to branch entries is required.
   // If random access to only a few branches is required, you should
   // call directly TBranch::LoadBaskets.

   if (maxmemory > 0) SetMaxVirtualSize(maxmemory);

   TIter next(GetListOfLeaves());
   TLeaf *leaf;
   Int_t nimported = 0;
   while ((leaf=(TLeaf*)next())) {
      nimported += leaf->GetBranch()->LoadBaskets();//break;
   }
   return nimported;
}

//______________________________________________________________________________
Long64_t TTree::LoadTree(Long64_t entry)
{
   // Set current entry.
   //
   // Returns -2 if entry does not exist (just as TChain::LoadTree()).
   //
   // Note: This function is overloaded in TChain.
   //

   // We already have been visited while recursively looking
   // through the friends tree, let return
   if (kLoadTree & fFriendLockStatus) {
      // We need to return a negative value to avoid a circular list of friend
      // to think that there is always an entry somewhere in the list.
      return -1;
   }

   if (fNotify) {
      if (fReadEntry < 0) {
         fNotify->Notify();
      }
   }
   fReadEntry = entry;

   Bool_t friendHasEntry = kFALSE;
   if (fFriends) {
      // Set current entry in friends as well.
      //
      // An alternative would move this code to each of the
      // functions calling LoadTree (and to overload a few more).
      Bool_t needUpdate = kFALSE;
      {
         // This scope is need to insure the lock is released at the right time
         TIter nextf(fFriends);
         TFriendLock lock(this, kLoadTree);
         TFriendElement* fe = 0;
         while ((fe = (TFriendElement*) nextf())) {
            if (fe->TestBit(TFriendElement::kFromChain)) {
               // This friend element was added by the chain that owns this
               // tree, the chain will deal with loading the correct entry.
               continue;
            }
            TTree* friendTree = fe->GetTree();
            if (friendTree == 0) {
               // Somehow we failed to retrieve the friend TTree.
            } else if (friendTree->IsA() == TTree::Class()) {
               // Friend is actually a tree.
               if (friendTree->LoadTreeFriend(entry, this) >= 0) {
                  friendHasEntry = kTRUE;
               }
            } else {
               // Friend is actually a chain.
               // FIXME: This logic should be in the TChain override.
               Int_t oldNumber = friendTree->GetTreeNumber();
               if (friendTree->LoadTreeFriend(entry, this) >= 0) {
                  friendHasEntry = kTRUE;
               }
               Int_t newNumber = friendTree->GetTreeNumber();
               if (oldNumber != newNumber) {
                  // We can not just compare the tree pointers because they could be reused.
                  // So we compare the tree number instead.
                  needUpdate = kTRUE;
               }
            }
         } // for each friend
      }
      if (needUpdate) {
         //update list of leaves in all TTreeFormula of the TTreePlayer (if any)
         if (fPlayer) {
            fPlayer->UpdateFormulaLeaves();
         }
         //Notify user if requested
         if (fNotify) {
            fNotify->Notify();
         }
      }
   }

   if ((fReadEntry >= fEntries) && !friendHasEntry) {
      fReadEntry = -1;
      return -2;
   }
   return fReadEntry;
}

//______________________________________________________________________________
Long64_t TTree::LoadTreeFriend(Long64_t entry, TTree* masterTree)
{
   // Load entry on behalf of our master tree, we may use an index.
   //
   // Called by LoadTree() when the masterTree looks for the entry
   // number in a friend tree (us) corresponding to the passed entry
   // number in the masterTree.
   //
   // If we have no index, our entry number and the masterTree entry
   // number are the same.
   //
   // If we *do* have an index, we must find the (major, minor) value pair
   // in masterTree to locate our corresponding entry.
   //

   if (!fTreeIndex) {
      return LoadTree(entry);
   }
   return LoadTree(fTreeIndex->GetEntryNumberFriend(masterTree));
}

//______________________________________________________________________________
Int_t TTree::MakeClass(const char* classname, Option_t* option)
{
   // Generate a skeleton analysis class for this tree.
   //
   // The following files are produced: classname.h and classname.C.
   // If classname is 0, classname will be called "nameoftree".
   //
   // The generated code in classname.h includes the following:
   //    - Identification of the original tree and the input file name.
   //    - Definition of an analysis class (data members and member functions).
   //    - The following member functions:
   //       - constructor (by default opening the tree file),
   //       - GetEntry(Long64_t entry),
   //       - Init(TTree* tree) to initialize a new TTree,
   //       - Show(Long64_t entry) to read and dump entry.
   //
   // The generated code in classname.C includes only the main
   // analysis function Loop.
   //
   // To use this function:
   //    - Open your tree file (eg: TFile f("myfile.root");)
   //    - T->MakeClass("MyClass");
   // where T is the name of the TTree in file myfile.root,
   // and MyClass.h, MyClass.C the name of the files created by this function.
   // In a ROOT session, you can do:
   //    root > .L MyClass.C
   //    root > MyClass* t = new MyClass;
   //    root > t->GetEntry(12); // Fill data members of t with entry number 12.
   //    root > t->Show();       // Show values of entry 12.
   //    root > t->Show(16);     // Read and show values of entry 16.
   //    root > t->Loop();       // Loop on all entries.
   //
   //  NOTE: Do not use the code generated for a single TTree which is part
   //        of a TChain to process that entire TChain.  The maximum dimensions
   //        calculated for arrays on the basis of a single TTree from the TChain
   //        might be (will be!) too small when processing all of the TTrees in
   //        the TChain.  You must use myChain.MakeClass() to generate the code,
   //        not myTree.MakeClass(...).
   //

   GetPlayer();
   if (!fPlayer) {
      return 0;
   }
   return fPlayer->MakeClass(classname, option);
}

//______________________________________________________________________________
Int_t TTree::MakeCode(const char* filename)
{
   // Generate a skeleton function for this tree.
   //
   // The function code is written on filename.
   // If filename is 0, filename will be called nameoftree.C
   //
   // The generated code includes the following:
   //    - Identification of the original Tree and Input file name,
   //    - Opening the Tree file,
   //    - Declaration of Tree variables,
   //    - Setting of branches addresses,
   //    - A skeleton for the entry loop.
   //
   // To use this function:
   //    - Open your Tree file (eg: TFile f("myfile.root");)
   //    - T->MakeCode("MyAnalysis.C");
   // where T is the name of the TTree in file myfile.root
   // and MyAnalysis.C the name of the file created by this function.
   //
   // NOTE: Since the implementation of this function, a new and better
   //       function TTree::MakeClass() has been developed.

   Warning("MakeCode", "MakeCode is obsolete. Use MakeClass or MakeSelector instead");

   GetPlayer();
   if (!fPlayer) return 0;
   return fPlayer->MakeCode(filename);
}

//______________________________________________________________________________
Int_t TTree::MakeProxy(const char* proxyClassname, const char* macrofilename, const char* cutfilename, const char* option, Int_t maxUnrolling)
{
   // Generate a skeleton analysis class for this Tree using TBranchProxy.
   //
   // TBranchProxy is the base of a class hierarchy implementing an
   // indirect access to the content of the branches of a TTree.
   //
   // "proxyClassname" is expected to be of the form:
   //    [path/]fileprefix
   // The skeleton will then be generated in the file:
   //    fileprefix.h
   // located in the current directory or in 'path/' if it is specified.
   // The class generated will be named 'fileprefix'
   //
   // "macrofilename" and optionally "cutfilename" are expected to point
   // to source files which will be included by the generated skeleton.
   // Method of the same name as the file(minus the extension and path)
   // will be called by the generated skeleton's Process method as follow:
   //    [if (cutfilename())] htemp->Fill(macrofilename());
   //
   // "option" can be used select some of the optional features during
   // the code generation.  The possible options are:
   //    nohist : indicates that the generated ProcessFill should not
   //             fill the histogram.
   //
   // 'maxUnrolling' controls how deep in the class hierarchy does the
   // system 'unroll' classes that are not split.  Unrolling a class
   // allows direct access to its data members (this emulates the behavior
   // of TTreeFormula).
   //
   // The main features of this skeleton are:
   //
   //    * on-demand loading of branches
   //    * ability to use the 'branchname' as if it was a data member
   //    * protection against array out-of-bounds errors
   //    * ability to use the branch data as an object (when the user code is available)
   //
   // For example with Event.root, if
   //    Double_t somePx = fTracks.fPx[2];
   // is executed by one of the method of the skeleton,
   // somePx will updated with the current value of fPx of the 3rd track.
   //
   // Both macrofilename and the optional cutfilename are expected to be
   // the name of source files which contain at least a free standing
   // function with the signature:
   //     x_t macrofilename(); // i.e function with the same name as the file
   // and
   //     y_t cutfilename();   // i.e function with the same name as the file
   //
   // x_t and y_t needs to be types that can convert respectively to a double
   // and a bool (because the skeleton uses:
   //     if (cutfilename()) htemp->Fill(macrofilename());
   //
   // These two functions are run in a context such that the branch names are
   // available as local variables of the correct (read-only) type.
   //
   // Note that if you use the same 'variable' twice, it is more efficient
   // to 'cache' the value. For example
   //   Int_t n = fEventNumber; // Read fEventNumber
   //   if (n<10 || n>10) { ... }
   // is more efficient than
   //   if (fEventNumber<10 || fEventNumber>10)
   //
   // Also, optionally, the generated selector will also call methods named
   // macrofilename_methodname in each of 6 main selector methods if the method
   // macrofilename_methodname exist (Where macrofilename is stripped of its
   // extension).
   //
   // Concretely, with the script named h1analysisProxy.C,
   //
   // The method         calls the method (if it exist)
   // Begin           -> void h1analysisProxy_Begin(TTree*);
   // SlaveBegin      -> void h1analysisProxy_SlaveBegin(TTree*);
   // Notify          -> Bool_t h1analysisProxy_Notify();
   // Process         -> Bool_t h1analysisProxy_Process(Long64_t);
   // SlaveTerminate  -> void h1analysisProxy_SlaveTerminate();
   // Terminate       -> void h1analysisProxy_Terminate();
   //
   // If a file name macrofilename.h (or .hh, .hpp, .hxx, .hPP, .hXX) exist
   // it is included before the declaration of the proxy class.  This can
   // be used in particular to insure that the include files needed by
   // the macro file are properly loaded.
   //
   // The default histogram is accessible via the variable named 'htemp'.
   //
   // If the library of the classes describing the data in the branch is
   // loaded, the skeleton will add the needed #include statements and
   // give the ability to access the object stored in the branches.
   //
   // To draw px using the file hsimple.root (generated by the
   // hsimple.C tutorial), we need a file named hsimple.cxx:
   //
   //     double hsimple() {
   //        return px;
   //     }
   //
   // MakeProxy can then be used indirectly via the TTree::Draw interface
   // as follow:
   //     new TFile("hsimple.root")
   //     ntuple->Draw("hsimple.cxx");
   //
   // A more complete example is available in the tutorials directory:
   //   h1analysisProxy.cxx , h1analysProxy.h and h1analysisProxyCut.C
   // which reimplement the selector found in h1analysis.C

   GetPlayer();
   if (!fPlayer) return 0;
   return fPlayer->MakeProxy(proxyClassname,macrofilename,cutfilename,option,maxUnrolling);
}

//______________________________________________________________________________
Int_t TTree::MakeSelector(const char* selector)
{
   // Generate skeleton selector class for this tree.
   //
   // The following files are produced: selector.h and selector.C.
   // If selector is 0, the selector will be called "nameoftree".
   //
   // The generated code in selector.h includes the following:
   //    - Identification of the original Tree and Input file name
   //    - Definition of selector class (data and functions)
   //    - The following class functions:
   //       - constructor and destructor
   //       - void    Begin(TTree *tree)
   //       - void    SlaveBegin(TTree *tree)
   //       - void    Init(TTree *tree)
   //       - Bool_t  Notify()
   //       - Bool_t  Process(Long64_t entry)
   //       - void    Terminate()
   //       - void    SlaveTerminate()
   //
   // The class selector derives from TSelector.
   // The generated code in selector.C includes empty functions defined above.
   //
   // To use this function:
   //    - connect your Tree file (eg: TFile f("myfile.root");)
   //    - T->MakeSelector("myselect");
   // where T is the name of the Tree in file myfile.root
   // and myselect.h, myselect.C the name of the files created by this function.
   // In a ROOT session, you can do:
   //    root > T->Process("myselect.C")

   return MakeClass(selector, "selector");
}

//______________________________________________________________________________
Bool_t TTree::MemoryFull(Int_t nbytes)
{
   // Check if adding nbytes to memory we are still below MaxVirtualsize.

   if ((fTotalBuffers + nbytes) < fMaxVirtualSize) {
      return kFALSE;
   }
   return kTRUE;
}

//______________________________________________________________________________
TTree* TTree::MergeTrees(TList* li, Option_t* options)
{
   // Static function merging the trees in the TList into a new tree.
   //
   // Trees in the list can be memory or disk-resident trees.
   // The new tree is created in the current directory (memory if gROOT).
   //

   if (!li) return 0;
   TIter next(li);
   TTree *newtree = 0;
   TObject *obj;

   while ((obj=next())) {
      if (!obj->InheritsFrom(TTree::Class())) continue;
      TTree *tree = (TTree*)obj;
      Long64_t nentries = tree->GetEntries();
      if (nentries == 0) continue;
      if (!newtree) {
         newtree = (TTree*)tree->CloneTree();
         if (!newtree) continue;

         // Once the cloning is done, separate the trees,
         // to avoid as many side-effects as possible
         // The list of clones is guaranteed to exist since we
         // just cloned the tree.
         tree->GetListOfClones()->Remove(newtree);
         tree->ResetBranchAddresses();
         newtree->ResetBranchAddresses();
         continue;
      }

      newtree->CopyAddresses(tree);

      newtree->CopyEntries(tree,-1,options);

      tree->ResetBranchAddresses(); // Disconnect from new tree.
   }
   if (newtree && newtree->GetTreeIndex()) {
      newtree->GetTreeIndex()->Append(0,kFALSE); // Force the sorting
   }
   return newtree;
}

//______________________________________________________________________________
Long64_t TTree::Merge(TCollection* li, Option_t *options)
{
   // Merge the trees in the TList into this tree.
   //
   // Returns the total number of entries in the merged tree.
   //

   if (!li) return 0;
   Long64_t storeAutoSave = fAutoSave;
   // Disable the autosave as the TFileMerge keeps a list of key and deleting the underlying
   // key would invalidate its iteration (or require costly measure to not use the deleted keys).
   // Also since this is part of a merging operation, the output file is not as precious as in
   // the general case since the input file should still be around.
   fAutoSave = 0;
   TIter next(li);
   TTree *tree;
   while ((tree = (TTree*)next())) {
      if (tree==this) continue;
      if (!tree->InheritsFrom(TTree::Class())) {
         Error("Add","Attempt to add object of class: %s to a %s", tree->ClassName(), ClassName());
         fAutoSave = storeAutoSave;
         return -1;
      }

      Long64_t nentries = tree->GetEntries();
      if (nentries == 0) continue;

      CopyAddresses(tree);

      CopyEntries(tree,-1,options);

      tree->ResetBranchAddresses();
   }
   fAutoSave = storeAutoSave;
   return GetEntries();
}

//______________________________________________________________________________
Long64_t TTree::Merge(TCollection* li, TFileMergeInfo *info)
{
   // Merge the trees in the TList into this tree.
   // If info->fIsFirst is true, first we clone this TTree info the directory
   // info->fOutputDirectory and then overlay the new TTree information onto
   // this TTree object (so that this TTree object is now the appropriate to
   // use for further merging).
   //
   // Returns the total number of entries in the merged tree.
   //

   const char *options = info ? info->fOptions.Data() : "";
   if (info && info->fIsFirst && info->fOutputDirectory && info->fOutputDirectory->GetFile() != GetCurrentFile()) {
      TDirectory::TContext ctxt(info->fOutputDirectory);
      TTree *newtree = CloneTree(-1, options);
      if (newtree) {
         newtree->Write();
         delete newtree;
      }
      // Make sure things are really written out to disk before attempting any reading.
      info->fOutputDirectory->GetFile()->Flush();
      info->fOutputDirectory->ReadTObject(this,this->GetName());
   }
   if (!li) return 0;
   Long64_t storeAutoSave = fAutoSave;
   // Disable the autosave as the TFileMerge keeps a list of key and deleting the underlying
   // key would invalidate its iteration (or require costly measure to not use the deleted keys).
   // Also since this is part of a merging operation, the output file is not as precious as in
   // the general case since the input file should still be around.
   fAutoSave = 0;
   TIter next(li);
   TTree *tree;
   while ((tree = (TTree*)next())) {
      if (tree==this) continue;
      if (!tree->InheritsFrom(TTree::Class())) {
         Error("Add","Attempt to add object of class: %s to a %s", tree->ClassName(), ClassName());
         fAutoSave = storeAutoSave;
         return -1;
      }
      // Copy MakeClass status.
      tree->SetMakeClass(fMakeClass);

      // Copy branch addresses.
      CopyAddresses(tree);

      CopyEntries(tree,-1,options);

      tree->ResetBranchAddresses();
   }
   fAutoSave = storeAutoSave;
   return GetEntries();
}

//______________________________________________________________________________
void TTree::MoveReadCache(TFile *src, TDirectory *dir)
{
   // Move a cache from a file to the current file in dir.
   // if src is null no operation is done, if dir is null or there is no
   // current file the cache is deleted.

   if (!src) return;
   TFile *dst = (dir && dir != gROOT) ? dir->GetFile() : 0;
   if (src == dst) return;

   TTreeCache *pf = GetReadCache(src);
   if (dst) {
      src->SetCacheRead(0,this);
      dst->SetCacheRead(pf, this);
   } else {
      if (pf) {
         pf->WaitFinishPrefetch();
      }
      src->SetCacheRead(0,this);
      delete pf;
   }
}

//______________________________________________________________________________
Bool_t TTree::Notify()
{
   // Function called when loading a new class library.

   TIter next(GetListOfLeaves());
   TLeaf* leaf = 0;
   while ((leaf = (TLeaf*) next())) {
      leaf->Notify();
      leaf->GetBranch()->Notify();
   }
   return kTRUE;
}

//______________________________________________________________________________
void TTree::OptimizeBaskets(ULong64_t maxMemory, Float_t minComp, Option_t *option)
{
   //This function may be called after having filled some entries in a Tree
   //Using the information in the existing branch buffers, it will reassign
   //new branch buffer sizes to optimize time and memory.
   //
   //The function computes the best values for branch buffer sizes such that
   //the total buffer sizes is less than maxMemory and nearby entries written
   //at the same time.
   //In case the branch compression factor for the data written so far is less
   //than compMin, the compression is disabled.
   //
   //if option ="d" an analysis report is printed.

   //Flush existing baskets if the file is writable
   if (this->GetDirectory()->IsWritable()) this->FlushBaskets();

   TString opt( option );
   opt.ToLower();
   Bool_t pDebug = opt.Contains("d");
   TObjArray *leaves = this->GetListOfLeaves();
   Int_t nleaves = leaves->GetEntries();
   Double_t treeSize = (Double_t)this->GetTotBytes();

   if (nleaves == 0 || treeSize == 0) {
      // We're being called too early, we really have nothing to do ...
      return;
   }
   Double_t aveSize = treeSize/nleaves;
   UInt_t bmin = 512;
   UInt_t bmax = 256000;
   Double_t memFactor = 1;
   Int_t i, oldMemsize,newMemsize,oldBaskets,newBaskets;
   i = oldMemsize = newMemsize = oldBaskets = newBaskets = 0;

   //we make two passes
   //one pass to compute the relative branch buffer sizes
   //a second pass to compute the absolute values
   for (Int_t pass =0;pass<2;pass++) {
      oldMemsize = 0;  //to count size of baskets in memory with old buffer size
      newMemsize = 0;  //to count size of baskets in memory with new buffer size
      oldBaskets = 0;  //to count number of baskets with old buffer size
      newBaskets = 0;  //to count number of baskets with new buffer size
      for (i=0;i<nleaves;i++) {
         TLeaf *leaf = (TLeaf*)leaves->At(i);
         TBranch *branch = leaf->GetBranch();
         Double_t totBytes = (Double_t)branch->GetTotBytes();
         Double_t idealFactor = totBytes/aveSize;
         UInt_t sizeOfOneEntry;
         if (branch->GetEntries() == 0) {
            // There is no data, so let's make a guess ...
            sizeOfOneEntry = aveSize;
         } else {
            sizeOfOneEntry = 1+(UInt_t)(totBytes / (Double_t)branch->GetEntries());
         }
         Int_t oldBsize = branch->GetBasketSize();
         oldMemsize += oldBsize;
         oldBaskets += 1+Int_t(totBytes/oldBsize);
         Int_t nb = branch->GetListOfBranches()->GetEntries();
         if (nb > 0) {
            newBaskets += 1+Int_t(totBytes/oldBsize);
            continue;
         }
         Double_t bsize = oldBsize*idealFactor*memFactor; //bsize can be very large !
         if (bsize < 0) bsize = bmax;
         if (bsize > bmax) bsize = bmax;
         UInt_t newBsize = UInt_t(bsize);
         newBsize = newBsize - newBsize%512;
         if (newBsize < sizeOfOneEntry) newBsize = sizeOfOneEntry;
         if (newBsize < bmin) newBsize = bmin;
         if (newBsize > 10000000) newBsize = bmax;
         if (pass) {
            if (pDebug) printf("Changing buffer size from %6d to %6d bytes for %s\n",oldBsize,newBsize,branch->GetName());
            branch->SetBasketSize(newBsize);
         }
         newMemsize += newBsize;
         // For this number to be somewhat accurate when newBsize is 'low'
         // we do not include any space for meta data in the requested size (newBsize) even-though SetBasketSize will
         // not let it be lower than 100+TBranch::fEntryOffsetLen.
         newBaskets += 1+Int_t(totBytes/newBsize);
         if (pass == 0) continue;
         //Reset the compression level in case the compression factor is small
         Double_t comp = 1;
         if (branch->GetZipBytes() > 0) comp = totBytes/Double_t(branch->GetZipBytes());
         if (comp > 1 && comp < minComp) {
            if (pDebug) printf("Disabling compression for branch : %s\n",branch->GetName());
            branch->SetCompressionSettings(0);
         }
      }
      // coverity[divide_by_zero] newMemsize can not be zero as there is at least one leaf
      memFactor = Double_t(maxMemory)/Double_t(newMemsize);
      if (memFactor > 100) memFactor = 100;
      Double_t bmin_new = bmin*memFactor;
      Double_t bmax_new = bmax*memFactor;
      static const UInt_t hardmax = 1*1024*1024*1024; // Really, really never give more than 1Gb to a single buffer.

      // Really, really never go lower than 8 bytes (we use this number
      // so that the calculation of the number of basket is consistent
      // but in fact SetBasketSize will not let the size go below
      // TBranch::fEntryOffsetLen + (100 + strlen(branch->GetName())
      // (The 2nd part being a slight over estimate of the key length.
      static const UInt_t hardmin = 8;
      bmin = (bmin_new > hardmax) ? hardmax : ( bmin_new < hardmin ? hardmin : (UInt_t)bmin_new );
      bmax = (bmax_new > hardmax) ? bmin : (UInt_t)bmax_new;
   }
   if (pDebug) {
      printf("oldMemsize = %d,  newMemsize = %d\n",oldMemsize, newMemsize);
      printf("oldBaskets = %d,  newBaskets = %d\n",oldBaskets, newBaskets);
   }
}

//______________________________________________________________________________
TPrincipal* TTree::Principal(const char* varexp, const char* selection, Option_t* option, Long64_t nentries, Long64_t firstentry)
{
   // Interface to the Principal Components Analysis class.
   //
   //   Create an instance of TPrincipal
   //   Fill it with the selected variables
   //   if option "n" is specified, the TPrincipal object is filled with
   //                 normalized variables.
   //   If option "p" is specified, compute the principal components
   //   If option "p" and "d" print results of analysis
   //   If option "p" and "h" generate standard histograms
   //   If option "p" and "c" generate code of conversion functions
   //   return a pointer to the TPrincipal object. It is the user responsibility
   //   to delete this object.
   //   The option default value is "np"
   //
   //   see TTree::Draw for explanation of the other parameters.
   //
   //   The created object is  named "principal" and a reference to it
   //   is added to the list of specials Root objects.
   //   you can retrieve a pointer to the created object via:
   //      TPrincipal *principal =
   //        (TPrincipal*)gROOT->GetListOfSpecials()->FindObject("principal");
   //

   GetPlayer();
   if (fPlayer) {
      return fPlayer->Principal(varexp, selection, option, nentries, firstentry);
   }
   return 0;
}

//______________________________________________________________________________
void TTree::Print(Option_t* option) const
{
   // Print a summary of the tree contents.
   //
   // If option contains "all" friend trees are also printed.
   // If option contains "toponly" only the top level branches are printed.
   // If option contains "clusters" information about the cluster of baskets is printed.
   //
   // Wildcarding can be used to print only a subset of the branches, e.g.,
   // T.Print("Elec*") will print all branches with name starting with "Elec".

   // We already have been visited while recursively looking
   // through the friends tree, let's return.
   if (kPrint & fFriendLockStatus) {
      return;
   }
   Int_t s = 0;
   Int_t skey = 0;
   if (fDirectory) {
      TKey* key = fDirectory->GetKey(GetName());
      if (key) {
         skey = key->GetKeylen();
         s = key->GetNbytes();
      }
   }
   Long64_t total = skey;
   if (fZipBytes > 0) {
      total += fTotBytes;
   }
   TBufferFile b(TBuffer::kWrite, 10000);
   TTree::Class()->WriteBuffer(b, (TTree*) this);
   total += b.Length();
   Long64_t file = fZipBytes + s;
   Float_t cx = 1;
   if (fZipBytes) {
      cx = (fTotBytes + 0.00001) / fZipBytes;
   }
   Printf("******************************************************************************");
   Printf("*Tree    :%-10s: %-54s *", GetName(), GetTitle());
   Printf("*Entries : %8lld : Total = %15lld bytes  File  Size = %10lld *", fEntries, total, file);
   Printf("*        :          : Tree compression factor = %6.2f                       *", cx);
   Printf("******************************************************************************");

   if (strncmp(option,"clusterRange",strlen("clusters"))==0) {
      Printf("%-16s %-16s %-16s %5s",
             "Cluster Range #", "Entry Start", "Last Entry", "Size");
      Int_t index= 0;
      Long64_t clusterRangeStart = 0;
      if (fNClusterRange) {
         for( ; index < fNClusterRange; ++index) {
            Printf("%-16d %-16lld %-16lld %5lld",
                   index, clusterRangeStart, fClusterRangeEnd[index], fClusterSize[index]);
            clusterRangeStart = fClusterRangeEnd[index] + 1;
         }
      }
      Printf("%-16d %-16lld %-16lld %5lld",
             index, clusterRangeStart, fEntries - 1, fAutoFlush);
      return;
   }

   Int_t nl = const_cast<TTree*>(this)->GetListOfLeaves()->GetEntries();
   Int_t l;
   TBranch* br = 0;
   TLeaf* leaf = 0;
   if (strstr(option, "toponly")) {
      Long64_t *count = new Long64_t[nl];
      Int_t keep =0;
      for (l=0;l<nl;l++) {
         leaf = (TLeaf *)const_cast<TTree*>(this)->GetListOfLeaves()->At(l);
         br   = leaf->GetBranch();
         if (strchr(br->GetName(),'.')) {
            count[l] = -1;
            count[keep] += br->GetZipBytes();
         } else {
            keep = l;
            count[keep]  = br->GetZipBytes();
         }
      }
      for (l=0;l<nl;l++) {
         if (count[l] < 0) continue;
         leaf = (TLeaf *)const_cast<TTree*>(this)->GetListOfLeaves()->At(l);
         br   = leaf->GetBranch();
         printf("branch: %-20s %9lld\n",br->GetName(),count[l]);
      }
      delete [] count;
   } else {
      TString reg = "*";
      if (strlen(option) && strchr(option,'*')) reg = option;
      TRegexp re(reg,kTRUE);
      TIter next(const_cast<TTree*>(this)->GetListOfBranches());
      TBranch::ResetCount();
      while ((br= (TBranch*)next())) {
         TString st = br->GetName();
         st.ReplaceAll("/","_");
         if (st.Index(re) == kNPOS) continue;
         br->Print(option);
      }
   }

   //print TRefTable (if one)
   if (fBranchRef) fBranchRef->Print(option);

   //print friends if option "all"
   if (!fFriends || !strstr(option,"all")) return;
   TIter nextf(fFriends);
   TFriendLock lock(const_cast<TTree*>(this),kPrint);
   TFriendElement *fr;
   while ((fr = (TFriendElement*)nextf())) {
      TTree * t = fr->GetTree();
      if (t) t->Print(option);
   }
}

//______________________________________________________________________________
void TTree::PrintCacheStats(Option_t* option) const
{
   // print statistics about the TreeCache for this tree, like
   //   ******TreeCache statistics for file: cms2.root ******
   //   Reading 73921562 bytes in 716 transactions
   //   Average transaction = 103.242405 Kbytes
   //   Number of blocks in current cache: 202, total size : 6001193
   //
   // if option = "a" the list of blocks in the cache is printed

   TFile *f = GetCurrentFile();
   if (!f) return;
   TTreeCache *tc = (TTreeCache*)f->GetCacheRead(const_cast<TTree*>(this));
   if (tc) tc->Print(option);
}

//______________________________________________________________________________
Long64_t TTree::Process(const char* filename, Option_t* option, Long64_t nentries, Long64_t firstentry)
{
   // Process this tree executing the TSelector code in the specified filename.
   // The return value is -1 in case of error and TSelector::GetStatus() in
   // in case of success.
   //
   // The code in filename is loaded (interpreted or compiled, see below),
   // filename must contain a valid class implementation derived from TSelector,
   // where TSelector has the following member functions:
   //
   //    Begin():        called every time a loop on the tree starts,
   //                    a convenient place to create your histograms.
   //    SlaveBegin():   called after Begin(), when on PROOF called only on the
   //                    slave servers.
   //    Process():      called for each event, in this function you decide what
   //                    to read and fill your histograms.
   //    SlaveTerminate: called at the end of the loop on the tree, when on PROOF
   //                    called only on the slave servers.
   //    Terminate():    called at the end of the loop on the tree,
   //                    a convenient place to draw/fit your histograms.
   //
   // If filename is of the form file.C, the file will be interpreted.
   // If filename is of the form file.C++, the file file.C will be compiled
   // and dynamically loaded.
   // If filename is of the form file.C+, the file file.C will be compiled
   // and dynamically loaded. At next call, if file.C is older than file.o
   // and file.so, the file.C is not compiled, only file.so is loaded.
   //
   //  NOTE1
   //  It may be more interesting to invoke directly the other Process function
   //  accepting a TSelector* as argument.eg
   //     MySelector *selector = (MySelector*)TSelector::GetSelector(filename);
   //     selector->CallSomeFunction(..);
   //     mytree.Process(selector,..);
   //
   //  NOTE2
   //  One should not call this function twice with the same selector file
   //  in the same script. If this is required, proceed as indicated in NOTE1,
   //  by getting a pointer to the corresponding TSelector,eg
   //    workaround 1
   //    ------------
   //void stubs1() {
   //   TSelector *selector = TSelector::GetSelector("h1test.C");
   //   TFile *f1 = new TFile("stubs_nood_le1.root");
   //   TTree *h1 = (TTree*)f1->Get("h1");
   //   h1->Process(selector);
   //   TFile *f2 = new TFile("stubs_nood_le1_coarse.root");
   //   TTree *h2 = (TTree*)f2->Get("h1");
   //   h2->Process(selector);
   //}
   //  or use ACLIC to compile the selector
   //   workaround 2
   //   ------------
   //void stubs2() {
   //   TFile *f1 = new TFile("stubs_nood_le1.root");
   //   TTree *h1 = (TTree*)f1->Get("h1");
   //   h1->Process("h1test.C+");
   //   TFile *f2 = new TFile("stubs_nood_le1_coarse.root");
   //   TTree *h2 = (TTree*)f2->Get("h1");
   //   h2->Process("h1test.C+");
   //}

   GetPlayer();
   if (fPlayer) {
      return fPlayer->Process(filename, option, nentries, firstentry);
   }
   return -1;
}

//______________________________________________________________________________
Long64_t TTree::Process(TSelector* selector, Option_t* option, Long64_t nentries, Long64_t firstentry)
{
   // Process this tree executing the code in the specified selector.
   // The return value is -1 in case of error and TSelector::GetStatus() in
   // in case of success.
   //
   //   The TSelector class has the following member functions:
   //
   //    Begin():        called every time a loop on the tree starts,
   //                    a convenient place to create your histograms.
   //    SlaveBegin():   called after Begin(), when on PROOF called only on the
   //                    slave servers.
   //    Process():      called for each event, in this function you decide what
   //                    to read and fill your histograms.
   //    SlaveTerminate: called at the end of the loop on the tree, when on PROOF
   //                    called only on the slave servers.
   //    Terminate():    called at the end of the loop on the tree,
   //                    a convenient place to draw/fit your histograms.
   //
   //  If the Tree (Chain) has an associated EventList, the loop is on the nentries
   //  of the EventList, starting at firstentry, otherwise the loop is on the
   //  specified Tree entries.

   GetPlayer();
   if (fPlayer) {
      return fPlayer->Process(selector, option, nentries, firstentry);
   }
   return -1;
}

//______________________________________________________________________________
Long64_t TTree::Project(const char* hname, const char* varexp, const char* selection, Option_t* option, Long64_t nentries, Long64_t firstentry)
{
   // Make a projection of a tree using selections.
   //
   // Depending on the value of varexp (described in Draw) a 1-D, 2-D, etc.,
   // projection of the tree will be filled in histogram hname.
   // Note that the dimension of hname must match with the dimension of varexp.
   //

   TString var;
   var.Form("%s>>%s", varexp, hname);
   TString opt("goff");
   if (option) {
      opt.Form("%sgoff", option);
   }
   Long64_t nsel = Draw(var, selection, opt, nentries, firstentry);
   return nsel;
}

//______________________________________________________________________________
TSQLResult* TTree::Query(const char* varexp, const char* selection, Option_t* option, Long64_t nentries, Long64_t firstentry)
{
   // Loop over entries and return a TSQLResult object containing entries following selection.

   GetPlayer();
   if (fPlayer) {
      return fPlayer->Query(varexp, selection, option, nentries, firstentry);
   }
   return 0;
}

//______________________________________________________________________________
Long64_t TTree::ReadFile(const char* filename, const char* branchDescriptor, char delimiter)
{
   // Create or simply read branches from filename.
   //
   // if branchDescriptor = "" (default), it is assumed that the Tree descriptor
   //    is given in the first line of the file with a syntax like
   //     A/D:Table[2]/F:Ntracks/I:astring/C
   //  otherwise branchDescriptor must be specified with the above syntax.
   //  -If the type of the first variable is not specified, it is assumed to be "/F"
   //  -if the type of any other variable is not specified, the type of the previous
   //    variable is assumed. eg
   //      x:y:z      (all variables are assumed of type "F"
   //      x/D:y:z    (all variables are of type "D"
   //      x:y/D:z    (x is type "F", y and z of type "D"
   //
   //  delimiter allows for the use of another delimiter besides whitespace.
   //    This provides support for direct import of common data file formats
   //    like csv.  If delimiter != ' ' and branchDescriptor == "", then the
   //    branch description is taken from the first line in the file, but
   //    delimiter is used for the branch names tokenization rather than ':'.
   //    Note however that if the values in the first line do not use the
   //    /[type] syntax, all variables are assumed to be of type "F".
   //    If the filename ends with extensions .csv or .CSV and a delimiter is
   //    not specified (besides ' '), the delimiter is automatically set to ','.
   //
   // Lines in the input file starting with "#" are ignored. Leading whitespace
   //   for each column data is skipped. Empty lines are skipped.
   //
   // A TBranch object is created for each variable in the expression.
   // The total number of rows read from the file is returned.
   //
   // FILLING a TTree WITH MULTIPLE INPUT TEXT FILES
   // ----------------------------------------------
   // To fill a TTree with multiple input text files, proceed as indicated above
   // for the first input file and omit the second argument for subsequent calls
   //    T.ReadFile("file1.dat","branch descriptor");
   //    T.ReadFile("file2.dat");

   std::ifstream in;
   in.open(filename);
   if (!in.good()) {
      Error("ReadFile","Cannot open file: %s",filename);
      return 0;
   }
   const char* ext = strrchr(filename, '.');
   if(ext != NULL && ((strcmp(ext, ".csv") == 0) || (strcmp(ext, ".CSV") == 0)) && delimiter == ' ') {
      delimiter = ',';
   }
   return ReadStream(in, branchDescriptor, delimiter);
}

//______________________________________________________________________________
char TTree::GetNewlineValue(std::istream &inputStream)
{
   // Determine which newline this file is using.
   // Return '\r' for Windows '\r\n' as that already terminates.

   Long_t inPos = inputStream.tellg();
   char newline = '\n';
   while(1) {
      char c = 0;
      inputStream.get(c);
      if(!inputStream.good()) {
         Error("ReadStream","Error reading stream: no newline found.");
         return 0;
      }
      if(c == newline) break;
      if(c == '\r') {
         newline = '\r';
         break;
      }
   }
   inputStream.clear();
   inputStream.seekg(inPos);
   return newline;
}

//______________________________________________________________________________
Long64_t TTree::ReadStream(std::istream& inputStream, const char *branchDescriptor, char delimiter)
{
   // Create or simply read branches from an input stream.
   //
   // See reference information for TTree::ReadFile

   char newline = GetNewlineValue(inputStream);
   std::istream& in = inputStream;
   Long64_t nlines = 0;

   TBranch *branch = 0;
   Int_t nbranches = fBranches.GetEntries();
   if (nbranches == 0) {
      char *bdname = new char[4000];
      char *bd = new char[100000];
      Int_t nch = 0;
      if (branchDescriptor) nch = strlen(branchDescriptor);
      // branch Descriptor is null, read its definition from the first line in the file
      if (!nch) {
         do {
            in.getline(bd, 100000, newline);
            if (!in.good()) {
               delete [] bdname;
               delete [] bd;
               Error("ReadStream","Error reading stream");
               return 0;
            }
            char *cursor = bd;
            while( isspace(*cursor) && *cursor != '\n' && *cursor != '\0') {
               ++cursor;
            }
            if (*cursor != '#' && *cursor != '\n' && *cursor != '\0') {
               break;
            }
         } while (true);
         ++nlines;
         nch = strlen(bd);
      } else {
         strlcpy(bd,branchDescriptor,100000);
      }

      //parse the branch descriptor and create a branch for each element
      //separated by ":"
      void *address = &bd[90000];
      char *bdcur = bd;
      TString desc="", olddesc="F";
      char bdelim = ':';
      if(delimiter != ' ') {
         bdelim = delimiter;
         if (strchr(bdcur,bdelim)==0 && strchr(bdcur,':') != 0) {
            // revert to the default
            bdelim = ':';
         }
      }
      while (bdcur) {
         char *colon = strchr(bdcur,bdelim);
         if (colon) *colon = 0;
         strlcpy(bdname,bdcur,4000);
         char *slash = strchr(bdname,'/');
         if (slash) {
            *slash = 0;
            desc = bdcur;
            olddesc = slash+1;
         } else {
            desc.Form("%s/%s",bdname,olddesc.Data());
         }
         char *bracket = strchr(bdname,'[');
         if (bracket) {
            *bracket = 0;
         }
         branch = new TBranch(this,bdname,address,desc.Data(),32000);
         if (branch->IsZombie()) {
            delete branch;
            Warning("ReadStream","Illegal branch definition: %s",bdcur);
         } else {
            fBranches.Add(branch);
            branch->SetAddress(0);
         }
         if (!colon)break;
         bdcur = colon+1;
      }
      delete [] bdname;
      delete [] bd;
   }

   nbranches = fBranches.GetEntries();

   if (gDebug > 1) {
      Info("ReadStream", "Will use branches:");
      for (int i = 0 ; i < nbranches; ++i) {
         TBranch* br = (TBranch*) fBranches.At(i);
         Info("ReadStream", "  %s: %s [%s]", br->GetName(),
              br->GetTitle(), br->GetListOfLeaves()->At(0)->IsA()->GetName());
      }
      if (gDebug > 3) {
         Info("ReadStream", "Dumping read tokens, format:");
         Info("ReadStream", "LLLLL:BBB:gfbe:GFBE:T");
         Info("ReadStream", "   L: line number");
         Info("ReadStream", "   B: branch number");
         Info("ReadStream", "   gfbe: good / fail / bad / eof of token");
         Info("ReadStream", "   GFBE: good / fail / bad / eof of file");
         Info("ReadStream", "   T: Token being read");
      }
   }

   //loop on all lines in the file
   Long64_t nGoodLines = 0;
   std::string line;
   const char sDelimBuf[2] = { delimiter, 0 };
   const char* sDelim = sDelimBuf;
   if (delimiter == ' ') {
      // ' ' really means whitespace
      sDelim = "[ \t]";
   }
   while(in.good()) {
      if (newline == '\r' && in.peek() == '\n') {
         // Windows, skip '\n':
         in.get();
      }
      std::getline(in, line, newline);
      ++nlines;

      TString sLine(line);
      sLine = sLine.Strip(TString::kLeading); // skip leading whitespace
      if (sLine.IsNull()) {
         if (gDebug > 2) {
            Info("ReadStream", "Skipping empty line number %lld", nlines);
         }
         continue; // silently skip empty lines
      }
      if (sLine[0] == '#') {
         if (gDebug > 2) {
            Info("ReadStream", "Skipping comment line number %lld: '%s'",
                 nlines, line.c_str());
         }
         continue;
      }
      if (gDebug > 2) {
         Info("ReadStream", "Parsing line number %lld: '%s'",
              nlines, line.c_str());
      }

      // Loop on branches and read the branch values into their buffer
      branch = 0;
      TString tok; // one column's data
      TString leafData; // leaf data, possibly multiple tokens for e.g. /I[2]
      std::stringstream sToken; // string stream feeding leafData into leaves
      Ssiz_t pos = 0;
      Int_t iBranch = 0;
      Bool_t goodLine = kTRUE; // whether the row can be filled into the tree
      Int_t remainingLeafLen = 0; // remaining columns for the current leaf
      while (goodLine && iBranch < nbranches
             && sLine.Tokenize(tok, pos, sDelim)) {
         tok = tok.Strip(TString::kLeading); // skip leading whitespace
         if (tok.IsNull() && delimiter == ' ') {
            // 1   2 should not be interpreted as 1,,,2 but 1, 2.
            // Thus continue until we have a non-empty token.
            continue;
         }

         if (!remainingLeafLen) {
            // next branch!
            branch = (TBranch*)fBranches.At(iBranch);
         }
         TLeaf *leaf = (TLeaf*)branch->GetListOfLeaves()->At(0);
         if (!remainingLeafLen) {
            remainingLeafLen = leaf->GetLen();
            if (leaf->GetMaximum() > 0) {
               // This is a dynamic leaf length, i.e. most likely a TLeafC's
               // string size. This still translates into one token:
               remainingLeafLen = 1;
            }

            leafData = tok;
         } else {
            // append token to laf data:
            leafData += " ";
            leafData += tok;
         }
         --remainingLeafLen;
         if (remainingLeafLen) {
            // need more columns for this branch:
            continue;
         }
         ++iBranch;

         // initialize stringstream with token
         sToken.clear();
         sToken.seekp(0, std::ios_base::beg);
         sToken.str(leafData.Data());
         sToken.seekg(0, std::ios_base::beg);
         leaf->ReadValue(sToken, 0 /* 0 = "all" */);
         if (gDebug > 3) {
            Info("ReadStream", "%5lld:%3d:%d%d%d%d:%d%d%d%d:%s",
                 nlines, iBranch,
                 (int)sToken.good(), (int)sToken.fail(),
                 (int)sToken.bad(), (int)sToken.eof(),
                 (int)in.good(), (int)in.fail(),
                 (int)in.bad(), (int)in.eof(),
                 sToken.str().c_str());
         }

         // Error handling
         if (sToken.bad()) {
            // How could that happen for a stringstream?
            Warning("ReadStream",
                    "Buffer error while reading data for branch %s on line %lld",
                    branch->GetName(), nlines);
         } else if (!sToken.eof()) {
            if (sToken.fail()) {
               Warning("ReadStream",
                       "Couldn't read formatted data in \"%s\" for branch %s on line %lld; ignoring line",
                       tok.Data(), branch->GetName(), nlines);
               goodLine = kFALSE;
            } else {
               std::string remainder;
               std::getline(sToken, remainder, newline);
               if (!remainder.empty()) {
                  Warning("ReadStream",
                          "Ignoring trailing \"%s\" while reading data for branch %s on line %lld",
                          remainder.c_str(), branch->GetName(), nlines);
               }
            }
         }
      } // tokenizer loop

      if (iBranch < nbranches) {
         Warning("ReadStream",
                 "Read too few columns (%d < %d) in line %lld; ignoring line",
                 iBranch, nbranches, nlines);
         goodLine = kFALSE;
      } else if (pos != kNPOS) {
         sLine = sLine.Strip(TString::kTrailing);
         if (pos < sLine.Length()) {
            Warning("ReadStream",
                    "Ignoring trailing \"%s\" while reading line %lld",
                    sLine.Data() + pos - 1 /* also print delimiter */,
                    nlines);
         }
      }

      //we are now ready to fill the tree
      if (goodLine) {
         Fill();
         ++nGoodLines;
      }
   }

   return nGoodLines;
}

//______________________________________________________________________________
void TTree::RecursiveRemove(TObject *obj)
{
   // Make sure that obj (which is being deleted or will soon be) is no
   // longer referenced by this TTree.

   if (obj == fEventList) {
      fEventList = 0;
   }
   if (obj == fEntryList) {
      fEntryList = 0;
   }
   if (fUserInfo) {
      fUserInfo->RecursiveRemove(obj);
   }
   if (fPlayer == obj) {
      fPlayer = 0;
   }
   if (fTreeIndex == obj) {
      fTreeIndex = 0;
   }
   if (fAliases) {
      fAliases->RecursiveRemove(obj);
   }
   if (fFriends) {
      fFriends->RecursiveRemove(obj);
   }
}

//______________________________________________________________________________
void TTree::Refresh()
{
   //  Refresh contents of this tree and its branches from the current status on disk.
   //
   //  One can call this function in case the tree file is being
   //  updated by another process.

   if (!fDirectory->GetFile()) {
      return;
   }
   fDirectory->ReadKeys();
   fDirectory->Remove(this);
   TTree* tree; fDirectory->GetObject(GetName(),tree);
   if (!tree) {
      return;
   }
   //copy info from tree header into this Tree
   fEntries = 0;
   fNClusterRange = 0;
   ImportClusterRanges(tree);

   fAutoSave = tree->fAutoSave;
   fEntries = tree->fEntries;
   fTotBytes = tree->fTotBytes;
   fZipBytes = tree->fZipBytes;
   fSavedBytes = tree->fSavedBytes;
   fTotalBuffers = tree->fTotalBuffers;

   //loop on all branches and update them
   Int_t nleaves = fLeaves.GetEntriesFast();
   for (Int_t i = 0; i < nleaves; i++)  {
      TLeaf* leaf = (TLeaf*) fLeaves.UncheckedAt(i);
      TBranch* branch = (TBranch*) leaf->GetBranch();
      branch->Refresh(tree->GetBranch(branch->GetName()));
   }
   fDirectory->Remove(tree);
   fDirectory->Append(this);
   delete tree;
   tree = 0;
}

//______________________________________________________________________________
void TTree::RemoveFriend(TTree* oldFriend)
{
   // Remove a friend from the list of friends.

   // We already have been visited while recursively looking
   // through the friends tree, let return
   if (kRemoveFriend & fFriendLockStatus) {
      return;
   }
   if (!fFriends) {
      return;
   }
   TFriendLock lock(this, kRemoveFriend);
   TIter nextf(fFriends);
   TFriendElement* fe = 0;
   while ((fe = (TFriendElement*) nextf())) {
      TTree* friend_t = fe->GetTree();
      if (friend_t == oldFriend) {
         fFriends->Remove(fe);
         delete fe;
         fe = 0;
      }
   }
}

//______________________________________________________________________________
void TTree::Reset(Option_t* option)
{
   // Reset baskets, buffers and entries count in all branches and leaves.

   fNotify        = 0;
   fEntries       = 0;
   fNClusterRange = 0;
   fTotBytes      = 0;
   fZipBytes      = 0;
   fFlushedBytes  = 0;
   fSavedBytes    = 0;
   fTotalBuffers  = 0;
   fChainOffset   = 0;
   fReadEntry     = -1;

   delete fTreeIndex;
   fTreeIndex = 0;

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

   if (fBranchRef) {
      fBranchRef->Reset();
   }
}
//______________________________________________________________________________
void TTree::ResetAfterMerge(TFileMergeInfo *info)
{
   // Resets the state of this TTree after a merge (keep the customization but
   // forget the data).

   fEntries       = 0;
   fNClusterRange = 0;
   fTotBytes      = 0;
   fZipBytes      = 0;
   fSavedBytes    = 0;
   fFlushedBytes  = 0;
   fTotalBuffers  = 0;
   fChainOffset   = 0;
   fReadEntry     = -1;

   delete fTreeIndex;
   fTreeIndex     = 0;

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

   if (fBranchRef) {
      fBranchRef->ResetAfterMerge(info);
   }
}

//______________________________________________________________________________
void TTree::ResetBranchAddress(TBranch *br)
{
   // Tell all of our branches to set their addresses to zero.
   //
   // Note: If any of our branches own any objects, they are deleted.

   if (br && br->GetTree()) {
      br->ResetAddress();
   }
}

//______________________________________________________________________________
void TTree::ResetBranchAddresses()
{
   // Tell all of our branches to drop their current objects and allocate new ones.

   TObjArray* branches = GetListOfBranches();
   Int_t nbranches = branches->GetEntriesFast();
   for (Int_t i = 0; i < nbranches; ++i) {
      TBranch* branch = (TBranch*) branches->UncheckedAt(i);
      branch->ResetAddress();
   }
}

//______________________________________________________________________________
Long64_t TTree::Scan(const char* varexp, const char* selection, Option_t* option, Long64_t nentries, Long64_t firstentry)
{
   // Loop over tree entries and print entries passing selection.
   //
   // If varexp is 0 (or "") then print only first 8 columns.
   // If varexp = "*" print all columns.
   // Otherwise a columns selection can be made using "var1:var2:var3".
   // See TTreePlayer::Scan for more information
   //

   GetPlayer();
   if (fPlayer) {
      return fPlayer->Scan(varexp, selection, option, nentries, firstentry);
   }
   return -1;
}

//______________________________________________________________________________
Bool_t TTree::SetAlias(const char* aliasName, const char* aliasFormula)
{
   // Set a tree variable alias.
   //
   //  Set an alias for an expression/formula based on the tree 'variables'.
   //
   //  The content of 'aliasName' can be used in TTreeFormula (i.e. TTree::Draw,
   //  TTree::Scan, TTreeViewer) and will be evaluated as the content of
   //  'aliasFormula'.
   //  If the content of 'aliasFormula' only contains symbol names, periods and
   //  array index specification (for example event.fTracks[3]), then
   //  the content of 'aliasName' can be used as the start of symbol.
   //
   //  If the alias 'aliasName' already existed, it is replaced by the new
   //  value.
   //
   //  When being used, the alias can be preceded by an eventual 'Friend Alias'
   //  (see TTree::GetFriendAlias)
   //
   //  Return true if it was added properly.
   //
   //  For example:
   //     tree->SetAlias("x1","(tdc1[1]-tdc1[0])/49");
   //     tree->SetAlias("y1","(tdc1[3]-tdc1[2])/47");
   //     tree->SetAlias("x2","(tdc2[1]-tdc2[0])/49");
   //     tree->SetAlias("y2","(tdc2[3]-tdc2[2])/47");
   //     tree->Draw("y2-y1:x2-x1");
   //
   //     tree->SetAlias("theGoodTrack","event.fTracks[3]");
   //     tree->Draw("theGoodTrack.fPx"); // same as "event.fTracks[3].fPx"

   if (!aliasName || !aliasFormula) {
      return kFALSE;
   }
   if (!aliasName[0] || !aliasFormula[0]) {
      return kFALSE;
   }
   if (!fAliases) {
      fAliases = new TList;
   } else {
      TNamed* oldHolder = (TNamed*) fAliases->FindObject(aliasName);
      if (oldHolder) {
         oldHolder->SetTitle(aliasFormula);
         return kTRUE;
      }
   }
   TNamed* holder = new TNamed(aliasName, aliasFormula);
   fAliases->Add(holder);
   return kTRUE;
}

//_______________________________________________________________________
void TTree::SetAutoFlush(Long64_t autof /* = -30000000 */ )
{
   // This function may be called at the start of a program to change
   // the default value for fAutoFlush.
   //
   //     CASE 1 : autof > 0
   //     ------------------
   // autof is the number of consecutive entries after which TTree::Fill will
   // flush all branch buffers to disk.
   //
   //     CASE 2 : autof < 0
   //     ------------------
   // When filling the Tree the branch buffers will be flushed to disk when
   // more than autof bytes have been written to the file. At the first FlushBaskets
   // TTree::Fill will replace fAutoFlush by the current value of fEntries.
   //
   // Calling this function with autof<0 is interesting when it is hard to estimate
   // the size of one entry. This value is also independent of the Tree.
   //
   // The Tree is initialized with fAutoFlush=-30000000, ie that, by default,
   // the first AutoFlush will be done when 30 MBytes of data are written to the file.
   //
   //     CASE 3 : autof = 0
   //     ------------------
   // The AutoFlush mechanism is disabled.
   //
   // Flushing the buffers at regular intervals optimize the location of
   // consecutive entries on the disk by creating clusters of baskets.
   //
   // A cluster of baskets is a set of baskets that contains all
   // the data for a (consecutive) set of entries and that is stored
   // consecutively on the disk.   When reading all the branches, this
   // is the minimum set of baskets that the TTreeCache will read.
   //
   //

   // Implementation note:
   //
   // A positive value of autoflush determines the size (in number of entries) of
   // a cluster of baskets.
   //
   // If the value of autoflush is changed over time (this happens in
   // particular when the TTree results from fast merging many trees),
   // we record the values of fAutoFlush in the data members:
   //     fClusterRangeEnd and fClusterSize.
   // In the code we refer to a range of entries where the size of the
   // cluster of baskets is the same (i.e the value of AutoFlush was
   // constant) is called a ClusterRange.
   //
   // The 2 arrays (fClusterRangeEnd and fClusterSize) have fNClusterRange
   // active (used) values and have fMaxClusterRange allocated entries.
   //
   // fClusterRangeEnd contains the last entries number of a cluster range.
   // In particular this means that the 'next' cluster starts at fClusterRangeEnd[]+1
   // fClusterSize contains the size in number of entries of all the cluster
   // within the given range.
   // The last range (and the only one if fNClusterRange is zero) start at
   // fNClusterRange[fNClusterRange-1]+1 and ends at the end of the TTree.  The
   // size of the cluster in this range is given by the value of fAutoFlush.
   //
   // For example printing the beginning and end of each the ranges can be done by:
   //
   //   Printf("%-16s %-16s %-16s %5s",
   //          "Cluster Range #", "Entry Start", "Last Entry", "Size");
   //   Int_t index= 0;
   //   Long64_t clusterRangeStart = 0;
   //   if (fNClusterRange) {
   //      for( ; index < fNClusterRange; ++index) {
   //         Printf("%-16d %-16lld %-16lld %5lld",
   //                index, clusterRangeStart, fClusterRangeEnd[index], fClusterSize[index]);
   //         clusterRangeStart = fClusterRangeEnd[index] + 1;
   //      }
   //   }
   //   Printf("%-16d %-16lld %-16lld %5lld",
   //          index, prevEntry, fEntries - 1, fAutoFlush);
   //

   // Note:  We store the entry number corresponding to the end of the cluster
   // rather than its start in order to avoid using the array if the cluster
   // size never varies (If there is only one value of AutoFlush for the whole TTree).

   if (fAutoFlush > 0 || autof > 0) {
      // The mechanism was already enabled, let's record the previous
      // cluster if needed.
      if (fFlushedBytes) {
         if ( (fNClusterRange+1) > fMaxClusterRange ) {
            if (fMaxClusterRange) {
               Int_t newsize = TMath::Max(10,Int_t(2*fMaxClusterRange));
               fClusterRangeEnd = (Long64_t*)TStorage::ReAlloc(fClusterRangeEnd,
                                                               newsize*sizeof(Long64_t),fMaxClusterRange*sizeof(Long64_t));
               fClusterSize = (Long64_t*)TStorage::ReAlloc(fClusterSize,
                                                           newsize*sizeof(Long64_t),fMaxClusterRange*sizeof(Long64_t));
               fMaxClusterRange = newsize;
            } else {
               fMaxClusterRange = 2;
               fClusterRangeEnd = new Long64_t[fMaxClusterRange];
               fClusterSize = new Long64_t[fMaxClusterRange];
            }
         }
         fClusterRangeEnd[fNClusterRange] = fEntries - 1;
         fClusterSize[fNClusterRange] = fAutoFlush<0 ? 0 : fAutoFlush;
         ++fNClusterRange;
      }
   }
   fAutoFlush = autof;
}

//_______________________________________________________________________
void TTree::SetAutoSave(Long64_t autos)
{
   //This function may be called at the start of a program to change
   //the default value for fAutoSave (and for SetAutoSave) is -300000000, ie 300 MBytes
   //When filling the Tree the branch buffers as well as the Tree header
   //will be flushed to disk when the watermark is reached.
   //If fAutoSave is positive the watermark is reached when a multiple of fAutoSave
   //entries have been written.
   //If fAutoSave is negative the watermark is reached when -fAutoSave bytes
   //have been written to the file.
   //In case of a program crash, it will be possible to recover the data in the Tree
   //up to the last AutoSave point.

   fAutoSave = autos;
}

//_______________________________________________________________________
void TTree::SetBasketSize(const char* bname, Int_t buffsize)
{
   // Set a branch's basket size.
   //
   // bname is the name of a branch.
   // if bname="*", apply to all branches.
   // if bname="xxx*", apply to all branches with name starting with xxx
   // see TRegexp for wildcarding options
   // buffsize = branc basket size
   //

   Int_t nleaves = fLeaves.GetEntriesFast();
   TRegexp re(bname, kTRUE);
   Int_t nb = 0;
   for (Int_t i = 0; i < nleaves; i++)  {
      TLeaf* leaf = (TLeaf*) fLeaves.UncheckedAt(i);
      TBranch* branch = (TBranch*) leaf->GetBranch();
      TString s = branch->GetName();
      if (strcmp(bname, branch->GetName()) && (s.Index(re) == kNPOS)) {
         continue;
      }
      nb++;
      branch->SetBasketSize(buffsize);
   }
   if (!nb) {
      Error("SetBasketSize", "unknown branch -> '%s'", bname);
   }
}

//_______________________________________________________________________
Int_t TTree::SetBranchAddress(const char* bname, void* addr, TBranch** ptr)
{
   // Change branch address, dealing with clone trees properly.
   // See TTree::CheckBranchAddressType for the semantic of the return value.
   //
   // Note: See the comments in TBranchElement::SetAddress() for the
   //       meaning of the addr parameter and the object ownership policy.
   //

   TBranch* branch = GetBranch(bname);
   if (!branch) {
      if (ptr) *ptr = 0;
      Error("SetBranchAddress", "unknown branch -> %s", bname);
      return kMissingBranch;
   }
   return SetBranchAddressImp(branch,addr,ptr);
}

//_______________________________________________________________________
Int_t TTree::SetBranchAddress(const char* bname, void* addr, TClass* ptrClass, EDataType datatype, Bool_t isptr)
{
   // Verify the validity of the type of addr before calling SetBranchAddress.
   // See TTree::CheckBranchAddressType for the semantic of the return value.
   //
   // Note: See the comments in TBranchElement::SetAddress() for the
   //       meaning of the addr parameter and the object ownership policy.
   //

   return SetBranchAddress(bname, addr, 0, ptrClass, datatype, isptr);
}

//_______________________________________________________________________
Int_t TTree::SetBranchAddress(const char* bname, void* addr, TBranch** ptr, TClass* ptrClass, EDataType datatype, Bool_t isptr)
{
   // Verify the validity of the type of addr before calling SetBranchAddress.
   // See TTree::CheckBranchAddressType for the semantic of the return value.
   //
   // Note: See the comments in TBranchElement::SetAddress() for the
   //       meaning of the addr parameter and the object ownership policy.
   //

   TBranch* branch = GetBranch(bname);
   if (!branch) {
      if (ptr) *ptr = 0;
      Error("SetBranchAddress", "unknown branch -> %s", bname);
      return kMissingBranch;
   }

   Int_t res = CheckBranchAddressType(branch, ptrClass, datatype, isptr);
   // This will set the value of *ptr to branch.
   if (res >= 0) {
      // The check succeeded.
      SetBranchAddressImp(branch,addr,ptr);
   } else {
      if (ptr) *ptr = 0;
   }
   return res;
}

//_______________________________________________________________________
Int_t TTree::SetBranchAddressImp(TBranch *branch, void* addr, TBranch** ptr)
{
   // Change branch address, dealing with clone trees properly.
   // See TTree::CheckBranchAddressType for the semantic of the return value.
   //
   // Note: See the comments in TBranchElement::SetAddress() for the
   //       meaning of the addr parameter and the object ownership policy.
   //

   if (ptr) {
      *ptr = branch;
   }
   if (fClones) {
      void* oldAddr = branch->GetAddress();
      TIter next(fClones);
      TTree* clone = 0;
      const char *bname = branch->GetName();
      while ((clone = (TTree*) next())) {
         TBranch* cloneBr = clone->GetBranch(bname);
         if (cloneBr && (cloneBr->GetAddress() == oldAddr)) {
            cloneBr->SetAddress(addr);
         }
      }
   }
   branch->SetAddress(addr);
   return kVoidPtr;
}


//_______________________________________________________________________
void TTree::SetBranchStatus(const char* bname, Bool_t status, UInt_t* found)
{
   // Set branch status to Process or DoNotProcess.
   //
   //  When reading a Tree, by default, all branches are read.
   //  One can speed up considerably the analysis phase by activating
   //  only the branches that hold variables involved in a query.
   //
   //     bname is the name of a branch.
   //     if bname="*", apply to all branches.
   //     if bname="xxx*", apply to all branches with name starting with xxx
   //     see TRegexp for wildcarding options
   //      status = 1  branch will be processed
   //             = 0  branch will not be processed
   //    Example:
   //  Assume a tree T with sub-branches a,b,c,d,e,f,g,etc..
   //  when doing T.GetEntry(i) all branches are read for entry i.
   //  to read only the branches c and e, one can do
   //    T.SetBranchStatus("*",0); //disable all branches
   //    T.SetBranchStatus("c",1);
   //    T.setBranchStatus("e",1);
   //    T.GetEntry(i);
   //
   //  bname is interpreted as a wildcarded TRegexp (see TRegexp::MakeWildcard).
   //  Thus, "a*b" or "a.*b" matches branches starting with "a" and ending with
   //  "b", but not any other branch with an "a" followed at some point by a
   //  "b". For this second behavior, use "*a*b*". Note that TRegExp does not
   //  support '|', and so you cannot select, e.g. track and shower branches
   //  with "track|shower".
   //
   //  WARNING! WARNING! WARNING!
   //  SetBranchStatus is matching the branch based on match of the branch
   //  'name' and not on the branch hierarchy! In order to be able to
   //  selectively enable a top level object that is 'split' you need to make
   //  sure the name of the top level branch is prefixed to the sub-branches'
   //  name (by adding a dot ('.') at the end of the Branch creation and use the
   //  corresponding bname.
   //
   //  I.e If your Tree has been created in split mode with a parent branch "parent."
   //  (note the trailing dot).
   //     T.SetBranchStatus("parent",1);
   //  will not activate the sub-branches of "parent". You should do:
   //     T.SetBranchStatus("parent*",1);
   //
   //  Without the trailing dot in the branch creation you have no choice but to
   //  call SetBranchStatus explicitly for each of the sub branches.
   //
   //
   //  An alternative to this function is to read directly and only
   //  the interesting branches. Example:
   //    TBranch *brc = T.GetBranch("c");
   //    TBranch *bre = T.GetBranch("e");
   //    brc->GetEntry(i);
   //    bre->GetEntry(i);
   //
   //  If found is not 0, the number of branch(es) found matching the regular
   //  expression is returned in *found AND the error message 'unknown branch'
   //  is suppressed.

   // We already have been visited while recursively looking
   // through the friends tree, let return
   if (kSetBranchStatus & fFriendLockStatus) {
      return;
   }

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

   Int_t i,j;
   Int_t nleaves = fLeaves.GetEntriesFast();
   TRegexp re(bname,kTRUE);
   Int_t nb = 0;

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

   //search in list of friends
   UInt_t foundInFriend = 0;
   if (fFriends) {
      TFriendLock lock(this,kSetBranchStatus);
      TIter nextf(fFriends);
      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);
         } else {
            name = bname;
         }
         t->SetBranchStatus(name,status, &foundInFriend);
      }
   }
   if (!nb && !foundInFriend) {
      if (found==0) Error("SetBranchStatus", "unknown branch -> %s", bname);
      return;
   }
   if (found) *found = nb + foundInFriend;

   // second pass, loop again on all branches
   // activate leafcount branches for active branches only
   for (i = 0; i < nleaves; i++) {
      leaf = (TLeaf*)fLeaves.UncheckedAt(i);
      branch = (TBranch*)leaf->GetBranch();
      if (!branch->TestBit(kDoNotProcess)) {
         leafcount = leaf->GetLeafCount();
         if (leafcount) {
            bcount = leafcount->GetBranch();
            bcount->ResetBit(kDoNotProcess);
         }
      } else {
         //Int_t nbranches = branch->GetListOfBranches()->GetEntriesFast();
         Int_t nbranches = branch->GetListOfBranches()->GetEntries();
         for (j=0;j<nbranches;j++) {
            bson = (TBranch*)branch->GetListOfBranches()->UncheckedAt(j);
            if (!bson) continue;
            if (!bson->TestBit(kDoNotProcess)) {
               if (bson->GetNleaves() <= 0) continue;
               branch->ResetBit(kDoNotProcess);
               break;
            }
         }
      }
   }
}

//______________________________________________________________________________
void TTree::SetBranchStyle(Int_t style)
{
   // Set the current branch style.  (static function)
   //
   // style = 0 old Branch
   // style = 1 new Bronch

   fgBranchStyle = style;
}

//______________________________________________________________________________
Int_t TTree::SetCacheSize(Long64_t cacheSize)
{
   // Set maximum size of the file cache .
   // if cachesize = 0 the existing cache (if any) is deleted.
   // if cachesize = -1 (default) it is set to the AutoFlush value when writing
   //    the Tree (default is 30 MBytes).
   // Returns  0 size set, cache was created if possible
   //         -1 on error

   // remember that the user has requested an explicit cache setup
   fCacheUserSet = kTRUE;

   return SetCacheSizeAux(kFALSE, cacheSize);
}

//______________________________________________________________________________
Int_t TTree::SetCacheSizeAux(Bool_t autocache /* = kTRUE */, Long64_t cacheSize /* = 0 */ )
{
   // Set the size of the file cache and create it if possible.
   //
   // If autocache is true:
   // this may be an autocreated cache, possibly enlarging an existing
   // autocreated cache. The size is calculated. The value passed in cacheSize:
   // cacheSize =  0  make cache if default cache creation is enabled
   // cacheSize = -1  make a default sized cache in any case
   //
   // If autocache is false:
   // this is a user requested cache. cacheSize is used to size the cache.
   // This cache should never be automatically adjusted.
   // Returns  0 size set, or existing autosized cache almost large enough.
   //            (cache was created if possible)
   //         -1 on error

   if (autocache) {
      // used as a once only control for automatic cache setup
      fCacheDoAutoInit = kFALSE;
   }

   if (!autocache) {
      // negative size means the user requests the default
      if (cacheSize < 0) {
         cacheSize = GetCacheAutoSize(kTRUE);
      }
   } else {
      if (cacheSize == 0) {
         cacheSize = GetCacheAutoSize();
      } else if (cacheSize < 0) {
         cacheSize = GetCacheAutoSize(kTRUE);
      }
   }

   TFile* file = GetCurrentFile();
   if (!file || GetTree() != this) {
      // if there's no file or we are not a plain tree (e.g. if we're a TChain)
      // do not create a cache, only record the size if one was given
      if (!autocache) {
         fCacheSize = cacheSize;
      }
      if (GetTree() != this) {
         return 0;
      }
      if (!autocache && cacheSize>0) {
         Warning("SetCacheSizeAux", "A TTreeCache could not be created because the TTree has no file");
      }
      return 0;
   }

   // Check for an existing cache
   TTreeCache* pf = GetReadCache(file);
   if (pf) {
      if (autocache) {
         // reset our cache status tracking in case existing cache was added
         // by the user without using one of the TTree methods
         fCacheSize = pf->GetBufferSize();
         fCacheUserSet = !pf->IsAutoCreated();

         if (fCacheUserSet) {
            // existing cache was created by the user, don't change it
            return 0;
         }
      } else {
         // update the cache to ensure it records the user has explicitly
         // requested it
         pf->SetAutoCreated(kFALSE);
      }

      // if we're using an automatically calculated size and the existing
      // cache is already almost large enough don't resize
      if (autocache && Long64_t(0.80*cacheSize) < fCacheSize) {
         // already large enough
         return 0;
      }

      if (cacheSize == fCacheSize) {
         return 0;
      }

      if (cacheSize == 0) {
         // delete existing cache
         pf->WaitFinishPrefetch();
         file->SetCacheRead(0,this);
         delete pf;
         pf = 0;
      } else {
         // resize
         Int_t res = pf->SetBufferSize(cacheSize);
         if (res < 0) {
            return -1;
         }
      }
   } else {
      // no existing cache
      if (autocache) {
         if (fCacheUserSet) {
            // value was already set manually.
            if (fCacheSize == 0) return 0;
            // Expected a cache should exist; perhaps the user moved it
            // Do nothing more here.
            if (cacheSize) {
               Error("SetCacheSizeAux", "Not setting up an automatically sized TTreeCache because of missing cache previously set");
            }
            return -1;
         }
      }
   }

   fCacheSize = cacheSize;
   if (cacheSize == 0 || pf) {
      return 0;
   }

   if(TTreeCacheUnzip::IsParallelUnzip() && file->GetCompressionLevel() > 0)
      pf = new TTreeCacheUnzip(this, cacheSize);
   else
      pf = new TTreeCache(this, cacheSize);

   pf->SetAutoCreated(autocache);

   return 0;
}

//______________________________________________________________________________
Int_t TTree::SetCacheEntryRange(Long64_t first, Long64_t last)
{
   //interface to TTreeCache to set the cache entry range
   // Returns  0 entry range set
   //         -1 on error

   if (!GetTree()) {
      if (LoadTree(0)<0) {
         Error("SetCacheEntryRange","Could not load a tree");
         return -1;
      }
   }
   if (GetTree()) {
      if (GetTree() != this) {
         return GetTree()->SetCacheEntryRange(first, last);
      }
   } else {
      Error("SetCacheEntryRange", "No tree is available. Could not set cache entry range");
      return -1;
   }

   TFile *f = GetCurrentFile();
   if (!f) {
      Error("SetCacheEntryRange", "No file is available. Could not set cache entry range");
      return -1;
   }
   TTreeCache *tc = GetReadCache(f,kTRUE);
   if (!tc) {
      Error("SetCacheEntryRange", "No cache is available. Could not set entry range");
      return -1;
   }
   tc->SetEntryRange(first,last);
   return 0;
}

//______________________________________________________________________________
void TTree::SetCacheLearnEntries(Int_t n)
{
   //interface to TTreeCache to set the number of entries for the learning phase

   TTreeCache::SetLearnEntries(n);
}

//______________________________________________________________________________
void TTree::SetCircular(Long64_t maxEntries)
{
   // Enable/Disable circularity for this tree.
   //
   // if maxEntries > 0 a maximum of maxEntries is kept in one buffer/basket
   // per branch in memory.
   //   Note that when this function is called (maxEntries>0) the Tree
   //   must be empty or having only one basket per branch.
   // if maxEntries <= 0 the tree circularity is disabled.
   //
   // NOTE 1:
   //  Circular Trees are interesting in online real time environments
   //  to store the results of the last maxEntries events.
   // NOTE 2:
   //  Calling SetCircular with maxEntries <= 0 is necessary before
   //  merging circular Trees that have been saved on files.
   // NOTE 3:
   //  SetCircular with maxEntries <= 0 is automatically called
   //  by TChain::Merge
   // NOTE 4:
   //  A circular Tree can still be saved in a file. When read back,
   //  it is still a circular Tree and can be filled again.

   if (maxEntries <= 0) {
      // Disable circularity.
      fMaxEntries = 1000000000;
      fMaxEntries *= 1000;
      ResetBit(kCircular);
      //in case the Tree was originally created in gROOT, the branch
      //compression level was set to -1. If the Tree is now associated to
      //a file, reset the compression level to the file compression level
      if (fDirectory) {
         TFile* bfile = fDirectory->GetFile();
         Int_t compress = 1;
         if (bfile) {
            compress = bfile->GetCompressionSettings();
         }
         Int_t nb = fBranches.GetEntriesFast();
         for (Int_t i = 0; i < nb; i++) {
            TBranch* branch = (TBranch*) fBranches.UncheckedAt(i);
            branch->SetCompressionSettings(compress);
         }
      }
   } else {
      // Enable circularity.
      fMaxEntries = maxEntries;
      SetBit(kCircular);
   }
}

//______________________________________________________________________________
void TTree::SetDebug(Int_t level, Long64_t min, Long64_t max)
{
   // Set the debug level and the debug range.
   //
   // For entries in the debug range, the functions TBranchElement::Fill
   // and TBranchElement::GetEntry will print the number of bytes filled
   // or read for each branch.

   fDebug = level;
   fDebugMin = min;
   fDebugMax = max;
}

//______________________________________________________________________________
void TTree::SetDefaultEntryOffsetLen(Int_t newdefault, Bool_t updateExisting)
{
   // Update the default value for the branch's fEntryOffsetLen.
   // If updateExisting is true, also update all the existing branches.
   // If newdefault is less than 10, the new default value will be 10.

   if (newdefault < 10) {
      newdefault = 10;
   }
   fDefaultEntryOffsetLen = newdefault;
   if (updateExisting) {
      TIter next( GetListOfBranches() );
      TBranch *b;
      while ( ( b = (TBranch*)next() ) ) {
         b->SetEntryOffsetLen( newdefault, kTRUE );
      }
      if (fBranchRef) {
         fBranchRef->SetEntryOffsetLen( newdefault, kTRUE );
      }
   }
}

//______________________________________________________________________________
void TTree::SetDirectory(TDirectory* dir)
{
   // Change the tree's directory.
   //
   // Remove reference to this tree from current directory and
   // add reference to new directory dir.  The dir parameter can
   // be 0 in which case the tree does not belong to any directory.
   //

   if (fDirectory == dir) {
      return;
   }
   if (fDirectory) {
      fDirectory->Remove(this);

      // Delete or move the file cache if it points to this Tree
      TFile *file = fDirectory->GetFile();
      MoveReadCache(file,dir);
   }
   fDirectory = dir;
   if (fDirectory) {
      fDirectory->Append(this);
   }
   TFile* file = 0;
   if (fDirectory) {
      file = fDirectory->GetFile();
   }
   if (fBranchRef) {
      fBranchRef->SetFile(file);
   }
   TBranch* b = 0;
   TIter next(GetListOfBranches());
   while((b = (TBranch*) next())) {
      b->SetFile(file);
   }
}

//_______________________________________________________________________
Long64_t TTree::SetEntries(Long64_t n)
{
   // Change number of entries in the tree.
   //
   // If n >= 0, set number of entries in the tree = n.
   //
   // If n < 0, set number of entries in the tree to match the
   // number of entries in each branch. (default for n is -1)
   //
   // This function should be called only when one fills each branch
   // independently via TBranch::Fill without calling TTree::Fill.
   // Calling TTree::SetEntries() make sense only if the number of entries
   // in each branch is identical, a warning is issued otherwise.
   // The function returns the number of entries.
   //

   // case 1 : force number of entries to n
   if (n >= 0) {
      fEntries = n;
      return n;
   }

   // case 2; compute the number of entries from the number of entries in the branches
   TBranch* b = 0;
   Long64_t nMin = 99999999;
   Long64_t nMax = 0;
   TIter next(GetListOfBranches());
   while((b = (TBranch*) next())){
      Long64_t n2 = b->GetEntries();
      if (n2 < nMin) {
         nMin = n2;
      }
      if (n2 > nMax) {
         nMax = n2;
      }
   }
   if (nMin != nMax) {
      Warning("SetEntries", "Tree branches have different numbers of entries, with %lld maximum.", nMax);
   }
   fEntries = nMax;
   return fEntries;
}

//_______________________________________________________________________
void TTree::SetEntryList(TEntryList *enlist, Option_t * /*opt*/)
{
   //Set an EntryList

   if (fEntryList) {
      //check if the previous entry list is owned by the tree
      if (fEntryList->TestBit(kCanDelete)){
         delete fEntryList;
      }
   }
   fEventList = 0;
   if (!enlist) {
      fEntryList = 0;
      return;
   }
   fEntryList = enlist;
   fEntryList->SetTree(this);

}

//_______________________________________________________________________
void TTree::SetEventList(TEventList *evlist)
{
//This function transfroms the given TEventList into a TEntryList
//The new TEntryList is owned by the TTree and gets deleted when the tree
//is deleted. This TEntryList can be returned by GetEntryList() function.

   fEventList = evlist;
   if (fEntryList){
      if (fEntryList->TestBit(kCanDelete)) {
         TEntryList *tmp = fEntryList;
         fEntryList = 0; // Avoid problem with RecursiveRemove.
         delete tmp;
      } else {
         fEntryList = 0;
      }
   }

   if (!evlist) {
      fEntryList = 0;
      fEventList = 0;
      return;
   }

   fEventList = evlist;
   char enlistname[100];
   snprintf(enlistname,100, "%s_%s", evlist->GetName(), "entrylist");
   fEntryList = new TEntryList(enlistname, evlist->GetTitle());
   fEntryList->SetDirectory(0); // We own this.
   Int_t nsel = evlist->GetN();
   fEntryList->SetTree(this);
   Long64_t entry;
   for (Int_t i=0; i<nsel; i++){
      entry = evlist->GetEntry(i);
      fEntryList->Enter(entry);
   }
   fEntryList->SetReapplyCut(evlist->GetReapplyCut());
   fEntryList->SetBit(kCanDelete, kTRUE);
}

//_______________________________________________________________________
void TTree::SetEstimate(Long64_t n /* = 1000000 */)
{
   // Set number of entries to estimate variable limits.
   // If n is -1, the estimate is set to be the current maximum
   // for the tree (i.e. GetEntries() + 1)
   // If n is less than -1, the behavior is undefined.

   if (n == 0) {
      n = 10000;
   } else if (n < 0) {
      n = fEntries - n;
   }
   fEstimate = n;
   GetPlayer();
   if (fPlayer) {
      fPlayer->SetEstimate(n);
   }
}

//_______________________________________________________________________
void TTree::SetFileNumber(Int_t number)
{
   // Set fFileNumber to number.
   // fFileNumber is used by TTree::Fill to set the file name
   // for a new file to be created when the current file exceeds fgTreeMaxSize.
   //    (see TTree::ChangeFile)
   // if fFileNumber=10, the new file name will have a suffix "_11",
   // ie, fFileNumber is incremented before setting the file name

   if (fFileNumber < 0) {
      Warning("SetFileNumber", "file number must be positive. Set to 0");
      fFileNumber = 0;
      return;
   }
   fFileNumber = number;
}

//______________________________________________________________________________
void TTree::SetMakeClass(Int_t make)
{
   // Set all the branches in this TTree to be in decomposed object mode
   // (also known as MakeClass mode).

   fMakeClass = make;

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

//______________________________________________________________________________
void TTree::SetMaxTreeSize(Long64_t maxsize)
{
   // Set the maximum size in bytes of a Tree file (static function).
   // The default size is 100000000000LL, ie 100 Gigabytes.
   //
   // In TTree::Fill, when the file has a size > fgMaxTreeSize,
   // the function closes the current file and starts writing into
   // a new file with a name of the style "file_1.root" if the original
   // requested file name was "file.root".
   //

   fgMaxTreeSize = maxsize;
}

//______________________________________________________________________________
void TTree::SetName(const char* name)
{
   // Change the name of this tree.

   if (gPad) {
      gPad->Modified();
   }
   // Trees are named objects in a THashList.
   // We must update hashlists if we change the name.
   TFile *file = 0;
   TTreeCache *pf = 0;
   if (fDirectory) {
      fDirectory->Remove(this);
      if ((file = GetCurrentFile())) {
         pf = GetReadCache(file);
         file->SetCacheRead(0,this,TFile::kDoNotDisconnect);
      }
   }
   // This changes our hash value.
   fName = name;
   if (fDirectory) {
      fDirectory->Append(this);
      if (pf) {
         file->SetCacheRead(pf,this,TFile::kDoNotDisconnect);
      }
   }
}

//______________________________________________________________________________
void TTree::SetObject(const char* name, const char* title)
{
   // Change the name and title of this tree.

   if (gPad) {
      gPad->Modified();
   }

   //  Trees are named objects in a THashList.
   //  We must update hashlists if we change the name
   TFile *file = 0;
   TTreeCache *pf = 0;
   if (fDirectory) {
      fDirectory->Remove(this);
      if ((file = GetCurrentFile())) {
         pf = GetReadCache(file);
         file->SetCacheRead(0,this,TFile::kDoNotDisconnect);
      }
   }
   // This changes our hash value.
   fName = name;
   fTitle = title;
   if (fDirectory) {
      fDirectory->Append(this);
      if (pf) {
         file->SetCacheRead(pf,this,TFile::kDoNotDisconnect);
      }
   }
}

//______________________________________________________________________________
void TTree::SetParallelUnzip(Bool_t opt, Float_t RelSize)
{
   // Enable or disable parallel unzipping of Tree buffers.

   if (opt) TTreeCacheUnzip::SetParallelUnzip(TTreeCacheUnzip::kEnable);
   else     TTreeCacheUnzip::SetParallelUnzip(TTreeCacheUnzip::kDisable);

   if (RelSize > 0) {
      TTreeCacheUnzip::SetUnzipRelBufferSize(RelSize);
   }

}

//______________________________________________________________________________
void TTree::SetPerfStats(TVirtualPerfStats *perf)
{
   fPerfStats = perf;
}
//______________________________________________________________________________
void TTree::SetTreeIndex(TVirtualIndex* index)
{
   // The current TreeIndex is replaced by the new index.
   // Note that this function does not delete the previous index.
   // This gives the possibility to play with more than one index, e.g.,
   // TVirtualIndex* oldIndex = tree.GetTreeIndex();
   // tree.SetTreeIndex(newIndex);
   // tree.Draw();
   // tree.SetTreeIndex(oldIndex);
   // tree.Draw(); etc

   if (fTreeIndex) {
      fTreeIndex->SetTree(0);
   }
   fTreeIndex = index;
}

//______________________________________________________________________________
void TTree::SetWeight(Double_t w, Option_t*)
{
   // Set tree weight.
   //
   // The weight is used by TTree::Draw to automatically weight each
   // selected entry in the resulting histogram.
   //
   // For example the equivalent of:
   //
   //      T.Draw("x", "w")
   //
   // is:
   //
   //      T.SetWeight(w);
   //      T.Draw("x");
   //
   // This function is redefined by TChain::SetWeight. In case of a
   // TChain, an option "global" may be specified to set the same weight
   // for all trees in the TChain instead of the default behaviour
   // using the weights of each tree in the chain (see TChain::SetWeight).

   fWeight = w;
}

//______________________________________________________________________________
void TTree::Show(Long64_t entry, Int_t lenmax)
{
   // Print values of all active leaves for entry.
   //
   // if entry==-1, print current entry (default)
   // if a leaf is an array, a maximum of lenmax elements is printed.
   //
   if (entry != -1) {
      Int_t ret = LoadTree(entry);
      if (ret == -2) {
         Error("Show()", "Cannot read entry %lld (entry does not exist)", entry);
         return;
      } else if (ret == -1) {
         Error("Show()", "Cannot read entry %lld (I/O error)", entry);
         return;
      }
      ret = GetEntry(entry);
      if (ret == -1) {
         Error("Show()", "Cannot read entry %lld (I/O error)", entry);
         return;
      } else if (ret == 0) {
         Error("Show()", "Cannot read entry %lld (no data read)", entry);
         return;
      }
   }
   printf("======> EVENT:%lld\n", fReadEntry);
   TObjArray* leaves  = GetListOfLeaves();
   Int_t nleaves = leaves->GetEntriesFast();
   Int_t ltype;
   for (Int_t i = 0; i < nleaves; i++) {
      TLeaf* leaf = (TLeaf*) leaves->UncheckedAt(i);
      TBranch* branch = leaf->GetBranch();
      if (branch->TestBit(kDoNotProcess)) {
         continue;
      }
      Int_t len = leaf->GetLen();
      if (len <= 0) {
         continue;
      }
      len = TMath::Min(len, lenmax);
      if (leaf->IsA() == TLeafElement::Class()) {
         leaf->PrintValue(lenmax);
         continue;
      }
      if (branch->GetListOfBranches()->GetEntriesFast() > 0) {
         continue;
      }
      ltype = 10;
      if (leaf->IsA() == TLeafF::Class()) {
         ltype = 5;
      }
      if (leaf->IsA() == TLeafD::Class()) {
         ltype = 5;
      }
      if (leaf->IsA() == TLeafC::Class()) {
         len = 1;
         ltype = 5;
      };
      printf(" %-15s = ", leaf->GetName());
      for (Int_t l = 0; l < len; l++) {
         leaf->PrintValue(l);
         if (l == (len - 1)) {
            printf("\n");
            continue;
         }
         printf(", ");
         if ((l % ltype) == 0) {
            printf("\n                  ");
         }
      }
   }
}

//______________________________________________________________________________
void TTree::StartViewer()
{
   // Start the TTreeViewer on this tree.
   //
   //  ww is the width of the canvas in pixels
   //  wh is the height of the canvas in pixels

   GetPlayer();
   if (fPlayer) {
      fPlayer->StartViewer(600, 400);
   }
}

//______________________________________________________________________________
Int_t TTree::StopCacheLearningPhase()
{
   // stop the cache learning phase
   // Returns  0 learning phase stopped or not active
   //         -1 on error

   if (!GetTree()) {
      if (LoadTree(0)<0) {
         Error("StopCacheLearningPhase","Could not load a tree");
         return -1;
      }
   }
   if (GetTree()) {
      if (GetTree() != this) {
         return GetTree()->StopCacheLearningPhase();
      }
   } else {
      Error("StopCacheLearningPhase", "No tree is available. Could not stop cache learning phase");
      return -1;
   }

   TFile *f = GetCurrentFile();
   if (!f) {
      Error("StopCacheLearningPhase", "No file is available. Could not stop cache learning phase");
      return -1;
   }
   TTreeCache *tc = GetReadCache(f,kTRUE);
   if (!tc) {
      Error("StopCacheLearningPhase", "No cache is available. Could not stop learning phase");
      return -1;
   }
   tc->StopLearningPhase();
   return 0;
}

//______________________________________________________________________________
static void TBranch__SetTree(TTree *tree, TObjArray &branches)
{
   // Set the fTree member for all branches and sub branches.

   Int_t nb = branches.GetEntriesFast();
   for (Int_t i = 0; i < nb; ++i) {
      TBranch* br = (TBranch*) branches.UncheckedAt(i);
      br->SetTree(tree);

      Int_t nBaskets = br->GetListOfBaskets()->GetEntries();
      Int_t writeBasket = br->GetWriteBasket();
      for (Int_t j=writeBasket,n=0;j>=0 && n<nBaskets;--j) {
         TBasket *bk = (TBasket*)br->GetListOfBaskets()->UncheckedAt(j);
         if (bk) {
            tree->IncrementTotalBuffers(bk->GetBufferSize());
            ++n;
         }
      }

      TBranch__SetTree(tree,*br->GetListOfBranches());
   }
}

//______________________________________________________________________________
void TFriendElement__SetTree(TTree *tree, TList *frlist)
{
   // Set the fTree member for all friend elements.

   if (frlist) {
      TObjLink *lnk = frlist->FirstLink();
      while (lnk) {
         TFriendElement *elem = (TFriendElement*)lnk->GetObject();
         elem->fParentTree = tree;
         lnk = lnk->Next();
      }
   }
}

//______________________________________________________________________________
void TTree::Streamer(TBuffer& b)
{
   // Stream a class object.
   if (b.IsReading()) {
      UInt_t R__s, R__c;
      if (fDirectory) {
         fDirectory->Remove(this);
         //delete the file cache if it points to this Tree
         TFile *file = fDirectory->GetFile();
         MoveReadCache(file,0);
      }
      fDirectory = 0;
      fCacheDoAutoInit = kTRUE;
      fCacheUserSet = kFALSE;
      Version_t R__v = b.ReadVersion(&R__s, &R__c);
      if (R__v > 4) {
         b.ReadClassBuffer(TTree::Class(), this, R__v, R__s, R__c);

         fBranches.SetOwner(kTRUE); // True needed only for R__v < 19 and most R__v == 19

         if (fBranchRef) fBranchRef->SetTree(this);
         TBranch__SetTree(this,fBranches);
         TFriendElement__SetTree(this,fFriends);

         if (fTreeIndex) {
            fTreeIndex->SetTree(this);
         }
         if (fIndex.fN) {
            Warning("Streamer", "Old style index in this tree is deleted. Rebuild the index via TTree::BuildIndex");
            fIndex.Set(0);
            fIndexValues.Set(0);
         }
         if (fEstimate <= 10000) {
            fEstimate = 1000000;
         }
         if (GetCacheAutoSize() != 0) {
            // a cache will be automatically created.
            // No need for TTreePlayer::Process to enable the cache
            fCacheSize = 0;
         } else if (fAutoFlush < 0) {
            // If there is no autoflush set, let's keep the cache completely
            // disable by default for now.
            fCacheSize = fAutoFlush;
         } else if (fAutoFlush != 0) {
            // Estimate the cluster size.
            // This will allow TTree::Process to enable the cache.
            if (fZipBytes != 0) {
               fCacheSize =  fAutoFlush*(fZipBytes/fEntries);
            } else if (fTotBytes != 0) {
               fCacheSize =  fAutoFlush*(fTotBytes/fEntries);
            } else {
               fCacheSize = 30000000;
            }
            if (fCacheSize >= (INT_MAX / 4)) {
               fCacheSize = INT_MAX / 4;
            } else if (fCacheSize == 0) {
               fCacheSize = 30000000;
            }
         } else {
            fCacheSize = 0;
         }
         ResetBit(kMustCleanup);
         return;
      }
      //====process old versions before automatic schema evolution
      Stat_t djunk;
      Int_t ijunk;
      TNamed::Streamer(b);
      TAttLine::Streamer(b);
      TAttFill::Streamer(b);
      TAttMarker::Streamer(b);
      b >> fScanField;
      b >> ijunk; fMaxEntryLoop   = (Long64_t)ijunk;
      b >> ijunk; fMaxVirtualSize = (Long64_t)ijunk;
      b >> djunk; fEntries  = (Long64_t)djunk;
      b >> djunk; fTotBytes = (Long64_t)djunk;
      b >> djunk; fZipBytes = (Long64_t)djunk;
      b >> ijunk; fAutoSave = (Long64_t)ijunk;
      b >> ijunk; fEstimate = (Long64_t)ijunk;
      if (fEstimate <= 10000) fEstimate = 1000000;
      fBranches.Streamer(b);
      if (fBranchRef) fBranchRef->SetTree(this);
      TBranch__SetTree(this,fBranches);
      fLeaves.Streamer(b);
      fSavedBytes = fTotBytes;
      if (R__v > 1) fIndexValues.Streamer(b);
      if (R__v > 2) fIndex.Streamer(b);
      if (R__v > 3) {
         TList OldInfoList;
         OldInfoList.Streamer(b);
         OldInfoList.Delete();
      }
      fNClusterRange = 0;
      fDefaultEntryOffsetLen = 1000;
      ResetBit(kMustCleanup);
      b.CheckByteCount(R__s, R__c, TTree::IsA());
      //====end of old versions
   } else {
      if (fBranchRef) {
         fBranchRef->Clear();
      }
      TRefTable *table  = TRefTable::GetRefTable();
      if (table) TRefTable::SetRefTable(0);

      b.WriteClassBuffer(TTree::Class(), this);

      if (table) TRefTable::SetRefTable(table);
   }
}

//______________________________________________________________________________
Int_t TTree::UnbinnedFit(const char* funcname, const char* varexp, const char* selection, Option_t* option, Long64_t nentries, Long64_t firstentry)
{
   // Unbinned fit of one or more variable(s) from a tree.
   //
   //  funcname is a TF1 function.
   //
   //  See TTree::Draw for explanations of the other parameters.
   //
   //   Fit the variable varexp using the function funcname using the
   //   selection cuts given by selection.
   //
   //   The list of fit options is given in parameter option.
   //      option = "Q" Quiet mode (minimum printing)
   //             = "V" Verbose mode (default is between Q and V)
   //             = "E" Perform better Errors estimation using Minos technique
   //             = "M" More. Improve fit results
   //
   //   You can specify boundary limits for some or all parameters via
   //        func->SetParLimits(p_number, parmin, parmax);
   //   if parmin>=parmax, the parameter is fixed
   //   Note that you are not forced to fix the limits for all parameters.
   //   For example, if you fit a function with 6 parameters, you can do:
   //     func->SetParameters(0,3.1,1.e-6,0.1,-8,100);
   //     func->SetParLimits(4,-10,-4);
   //     func->SetParLimits(5, 1,1);
   //   With this setup, parameters 0->3 can vary freely
   //   Parameter 4 has boundaries [-10,-4] with initial value -8
   //   Parameter 5 is fixed to 100.
   //
   //   For the fit to be meaningful, the function must be self-normalized.
   //
   //   i.e. It must have the same integral regardless of the parameter
   //   settings.  Otherwise the fit will effectively just maximize the
   //   area.
   //
   //   It is mandatory to have a normalization variable
   //   which is fixed for the fit.  e.g.
   //
   //     TF1* f1 = new TF1("f1", "gaus(0)/sqrt(2*3.14159)/[2]", 0, 5);
   //     f1->SetParameters(1, 3.1, 0.01);
   //     f1->SetParLimits(0, 1, 1); // fix the normalization parameter to 1
   //     data->UnbinnedFit("f1", "jpsimass", "jpsipt>3.0");
   //   //
   //
   //   1, 2 and 3 Dimensional fits are supported.
   //   See also TTree::Fit
   //
   //    Return status
   //    =============
   //   The function return the status of the fit in the following form
   //     fitResult = migradResult + 10*minosResult + 100*hesseResult + 1000*improveResult
   //   The fitResult is 0 is the fit is OK.
   //   The fitResult is negative in case of an error not connected with the fit.
   //   The number of entries used in the fit can be obtained via
   //     mytree.GetSelectedRows();
   //   If the number of selected entries is null the function returns -1

   GetPlayer();
   if (fPlayer) {
      return fPlayer->UnbinnedFit(funcname, varexp, selection, option, nentries, firstentry);
   }
   return -1;
}

//______________________________________________________________________________
void TTree::UseCurrentStyle()
{
   // Replace current attributes by current style.

   if (gStyle->IsReading()) {
      SetFillColor(gStyle->GetHistFillColor());
      SetFillStyle(gStyle->GetHistFillStyle());
      SetLineColor(gStyle->GetHistLineColor());
      SetLineStyle(gStyle->GetHistLineStyle());
      SetLineWidth(gStyle->GetHistLineWidth());
      SetMarkerColor(gStyle->GetMarkerColor());
      SetMarkerStyle(gStyle->GetMarkerStyle());
      SetMarkerSize(gStyle->GetMarkerSize());
   } else {
      gStyle->SetHistFillColor(GetFillColor());
      gStyle->SetHistFillStyle(GetFillStyle());
      gStyle->SetHistLineColor(GetLineColor());
      gStyle->SetHistLineStyle(GetLineStyle());
      gStyle->SetHistLineWidth(GetLineWidth());
      gStyle->SetMarkerColor(GetMarkerColor());
      gStyle->SetMarkerStyle(GetMarkerStyle());
      gStyle->SetMarkerSize(GetMarkerSize());
   }
}

//______________________________________________________________________________
Int_t TTree::Write(const char *name, Int_t option, Int_t bufsize) const
{
   // Write this object to the current directory. For more see TObject::Write
   // Write calls TTree::FlushBaskets before writing the tree.

   FlushBaskets();
   return TObject::Write(name, option, bufsize);
}

//______________________________________________________________________________
Int_t TTree::Write(const char *name, Int_t option, Int_t bufsize)
{
   // Write this object to the current directory. For more see TObject::Write
   // If option & kFlushBasket, call FlushBasket before writing the tree.

   return ((const TTree*)this)->Write(name, option, bufsize);
}

//////////////////////////////////////////////////////////////////////////
//                                                                      //
// TTreeFriendLeafIter                                                  //
//                                                                      //
// Iterator on all the leaves in a TTree and its friend                 //
//                                                                      //
//////////////////////////////////////////////////////////////////////////

ClassImp(TTreeFriendLeafIter)

//______________________________________________________________________________
TTreeFriendLeafIter::TTreeFriendLeafIter(const TTree* tree, Bool_t dir)
: fTree(const_cast<TTree*>(tree))
, fLeafIter(0)
, fTreeIter(0)
, fDirection(dir)
{
   // Create a new iterator. By default the iteration direction
   // is kIterForward. To go backward use kIterBackward.
}

//______________________________________________________________________________
TTreeFriendLeafIter::TTreeFriendLeafIter(const TTreeFriendLeafIter& iter)
: TIterator(iter)
, fTree(iter.fTree)
, fLeafIter(0)
, fTreeIter(0)
, fDirection(iter.fDirection)
{
   // Copy constructor.  Does NOT copy the 'cursor' location!

}

//______________________________________________________________________________
TIterator& TTreeFriendLeafIter::operator=(const TIterator& rhs)
{
   // Overridden assignment operator. Does NOT copy the 'cursor' location!

   if (this != &rhs && rhs.IsA() == TTreeFriendLeafIter::Class()) {
      const TTreeFriendLeafIter &rhs1 = (const TTreeFriendLeafIter &)rhs;
      fDirection = rhs1.fDirection;
   }
   return *this;
}

//______________________________________________________________________________
TTreeFriendLeafIter& TTreeFriendLeafIter::operator=(const TTreeFriendLeafIter& rhs)
{
   // Overridden assignment operator.  Does NOT copy the 'cursor' location!

   if (this != &rhs) {
      fDirection = rhs.fDirection;
   }
   return *this;
}

//______________________________________________________________________________
TObject* TTreeFriendLeafIter::Next()
{
   // Go the next friend element

   if (!fTree) return 0;

   TObject * next;
   TTree * nextTree;

   if (!fLeafIter) {
      TObjArray *list = fTree->GetListOfLeaves();
      if (!list) return 0; // Can happen with an empty chain.
      fLeafIter =  list->MakeIterator(fDirection);
      if (!fLeafIter) return 0;
   }

   next = fLeafIter->Next();
   if (!next) {
      if (!fTreeIter) {
         TCollection * list = fTree->GetListOfFriends();
         if (!list) return next;
         fTreeIter = list->MakeIterator(fDirection);
         if (!fTreeIter) return 0;
      }
      TFriendElement * nextFriend = (TFriendElement*) fTreeIter->Next();
      ///nextTree = (TTree*)fTreeIter->Next();
      if (nextFriend) {
         nextTree = const_cast<TTree*>(nextFriend->GetTree());
         if (!nextTree) return Next();
         SafeDelete(fLeafIter);
         fLeafIter = nextTree->GetListOfLeaves()->MakeIterator(fDirection);
         if (!fLeafIter) return 0;
         next = fLeafIter->Next();
      }
   }
   return next;
}

//______________________________________________________________________________
Option_t* TTreeFriendLeafIter::GetOption() const
{
   // Returns the object option stored in the list.

   if (fLeafIter) return fLeafIter->GetOption();
   return "";
}
 TTree.cxx:1
 TTree.cxx:2
 TTree.cxx:3
 TTree.cxx:4
 TTree.cxx:5
 TTree.cxx:6
 TTree.cxx:7
 TTree.cxx:8
 TTree.cxx:9
 TTree.cxx:10
 TTree.cxx:11
 TTree.cxx:12
 TTree.cxx:13
 TTree.cxx:14
 TTree.cxx:15
 TTree.cxx:16
 TTree.cxx:17
 TTree.cxx:18
 TTree.cxx:19
 TTree.cxx:20
 TTree.cxx:21
 TTree.cxx:22
 TTree.cxx:23
 TTree.cxx:24
 TTree.cxx:25
 TTree.cxx:26
 TTree.cxx:27
 TTree.cxx:28
 TTree.cxx:29
 TTree.cxx:30
 TTree.cxx:31
 TTree.cxx:32
 TTree.cxx:33
 TTree.cxx:34
 TTree.cxx:35
 TTree.cxx:36
 TTree.cxx:37
 TTree.cxx:38
 TTree.cxx:39
 TTree.cxx:40
 TTree.cxx:41
 TTree.cxx:42
 TTree.cxx:43
 TTree.cxx:44
 TTree.cxx:45
 TTree.cxx:46
 TTree.cxx:47
 TTree.cxx:48
 TTree.cxx:49
 TTree.cxx:50
 TTree.cxx:51
 TTree.cxx:52
 TTree.cxx:53
 TTree.cxx:54
 TTree.cxx:55
 TTree.cxx:56
 TTree.cxx:57
 TTree.cxx:58
 TTree.cxx:59
 TTree.cxx:60
 TTree.cxx:61
 TTree.cxx:62
 TTree.cxx:63
 TTree.cxx:64
 TTree.cxx:65
 TTree.cxx:66
 TTree.cxx:67
 TTree.cxx:68
 TTree.cxx:69
 TTree.cxx:70
 TTree.cxx:71
 TTree.cxx:72
 TTree.cxx:73
 TTree.cxx:74
 TTree.cxx:75
 TTree.cxx:76
 TTree.cxx:77
 TTree.cxx:78
 TTree.cxx:79
 TTree.cxx:80
 TTree.cxx:81
 TTree.cxx:82
 TTree.cxx:83
 TTree.cxx:84
 TTree.cxx:85
 TTree.cxx:86
 TTree.cxx:87
 TTree.cxx:88
 TTree.cxx:89
 TTree.cxx:90
 TTree.cxx:91
 TTree.cxx:92
 TTree.cxx:93
 TTree.cxx:94
 TTree.cxx:95
 TTree.cxx:96
 TTree.cxx:97
 TTree.cxx:98
 TTree.cxx:99
 TTree.cxx:100
 TTree.cxx:101
 TTree.cxx:102
 TTree.cxx:103
 TTree.cxx:104
 TTree.cxx:105
 TTree.cxx:106
 TTree.cxx:107
 TTree.cxx:108
 TTree.cxx:109
 TTree.cxx:110
 TTree.cxx:111
 TTree.cxx:112
 TTree.cxx:113
 TTree.cxx:114
 TTree.cxx:115
 TTree.cxx:116
 TTree.cxx:117
 TTree.cxx:118
 TTree.cxx:119
 TTree.cxx:120
 TTree.cxx:121
 TTree.cxx:122
 TTree.cxx:123
 TTree.cxx:124
 TTree.cxx:125
 TTree.cxx:126
 TTree.cxx:127
 TTree.cxx:128
 TTree.cxx:129
 TTree.cxx:130
 TTree.cxx:131
 TTree.cxx:132
 TTree.cxx:133
 TTree.cxx:134
 TTree.cxx:135
 TTree.cxx:136
 TTree.cxx:137
 TTree.cxx:138
 TTree.cxx:139
 TTree.cxx:140
 TTree.cxx:141
 TTree.cxx:142
 TTree.cxx:143
 TTree.cxx:144
 TTree.cxx:145
 TTree.cxx:146
 TTree.cxx:147
 TTree.cxx:148
 TTree.cxx:149
 TTree.cxx:150
 TTree.cxx:151
 TTree.cxx:152
 TTree.cxx:153
 TTree.cxx:154
 TTree.cxx:155
 TTree.cxx:156
 TTree.cxx:157
 TTree.cxx:158
 TTree.cxx:159
 TTree.cxx:160
 TTree.cxx:161
 TTree.cxx:162
 TTree.cxx:163
 TTree.cxx:164
 TTree.cxx:165
 TTree.cxx:166
 TTree.cxx:167
 TTree.cxx:168
 TTree.cxx:169
 TTree.cxx:170
 TTree.cxx:171
 TTree.cxx:172
 TTree.cxx:173
 TTree.cxx:174
 TTree.cxx:175
 TTree.cxx:176
 TTree.cxx:177
 TTree.cxx:178
 TTree.cxx:179
 TTree.cxx:180
 TTree.cxx:181
 TTree.cxx:182
 TTree.cxx:183
 TTree.cxx:184
 TTree.cxx:185
 TTree.cxx:186
 TTree.cxx:187
 TTree.cxx:188
 TTree.cxx:189
 TTree.cxx:190
 TTree.cxx:191
 TTree.cxx:192
 TTree.cxx:193
 TTree.cxx:194
 TTree.cxx:195
 TTree.cxx:196
 TTree.cxx:197
 TTree.cxx:198
 TTree.cxx:199
 TTree.cxx:200
 TTree.cxx:201
 TTree.cxx:202
 TTree.cxx:203
 TTree.cxx:204
 TTree.cxx:205
 TTree.cxx:206
 TTree.cxx:207
 TTree.cxx:208
 TTree.cxx:209
 TTree.cxx:210
 TTree.cxx:211
 TTree.cxx:212
 TTree.cxx:213
 TTree.cxx:214
 TTree.cxx:215
 TTree.cxx:216
 TTree.cxx:217
 TTree.cxx:218
 TTree.cxx:219
 TTree.cxx:220
 TTree.cxx:221
 TTree.cxx:222
 TTree.cxx:223
 TTree.cxx:224
 TTree.cxx:225
 TTree.cxx:226
 TTree.cxx:227
 TTree.cxx:228
 TTree.cxx:229
 TTree.cxx:230
 TTree.cxx:231
 TTree.cxx:232
 TTree.cxx:233
 TTree.cxx:234
 TTree.cxx:235
 TTree.cxx:236
 TTree.cxx:237
 TTree.cxx:238
 TTree.cxx:239
 TTree.cxx:240
 TTree.cxx:241
 TTree.cxx:242
 TTree.cxx:243
 TTree.cxx:244
 TTree.cxx:245
 TTree.cxx:246
 TTree.cxx:247
 TTree.cxx:248
 TTree.cxx:249
 TTree.cxx:250
 TTree.cxx:251
 TTree.cxx:252
 TTree.cxx:253
 TTree.cxx:254
 TTree.cxx:255
 TTree.cxx:256
 TTree.cxx:257
 TTree.cxx:258
 TTree.cxx:259
 TTree.cxx:260
 TTree.cxx:261
 TTree.cxx:262
 TTree.cxx:263
 TTree.cxx:264
 TTree.cxx:265
 TTree.cxx:266
 TTree.cxx:267
 TTree.cxx:268
 TTree.cxx:269
 TTree.cxx:270
 TTree.cxx:271
 TTree.cxx:272
 TTree.cxx:273
 TTree.cxx:274
 TTree.cxx:275
 TTree.cxx:276
 TTree.cxx:277
 TTree.cxx:278
 TTree.cxx:279
 TTree.cxx:280
 TTree.cxx:281
 TTree.cxx:282
 TTree.cxx:283
 TTree.cxx:284
 TTree.cxx:285
 TTree.cxx:286
 TTree.cxx:287
 TTree.cxx:288
 TTree.cxx:289
 TTree.cxx:290
 TTree.cxx:291
 TTree.cxx:292
 TTree.cxx:293
 TTree.cxx:294
 TTree.cxx:295
 TTree.cxx:296
 TTree.cxx:297
 TTree.cxx:298
 TTree.cxx:299
 TTree.cxx:300
 TTree.cxx:301
 TTree.cxx:302
 TTree.cxx:303
 TTree.cxx:304
 TTree.cxx:305
 TTree.cxx:306
 TTree.cxx:307
 TTree.cxx:308
 TTree.cxx:309
 TTree.cxx:310
 TTree.cxx:311
 TTree.cxx:312
 TTree.cxx:313
 TTree.cxx:314
 TTree.cxx:315
 TTree.cxx:316
 TTree.cxx:317
 TTree.cxx:318
 TTree.cxx:319
 TTree.cxx:320
 TTree.cxx:321
 TTree.cxx:322
 TTree.cxx:323
 TTree.cxx:324
 TTree.cxx:325
 TTree.cxx:326
 TTree.cxx:327
 TTree.cxx:328
 TTree.cxx:329
 TTree.cxx:330
 TTree.cxx:331
 TTree.cxx:332
 TTree.cxx:333
 TTree.cxx:334
 TTree.cxx:335
 TTree.cxx:336
 TTree.cxx:337
 TTree.cxx:338
 TTree.cxx:339
 TTree.cxx:340
 TTree.cxx:341
 TTree.cxx:342
 TTree.cxx:343
 TTree.cxx:344
 TTree.cxx:345
 TTree.cxx:346
 TTree.cxx:347
 TTree.cxx:348
 TTree.cxx:349
 TTree.cxx:350
 TTree.cxx:351
 TTree.cxx:352
 TTree.cxx:353
 TTree.cxx:354
 TTree.cxx:355
 TTree.cxx:356
 TTree.cxx:357
 TTree.cxx:358
 TTree.cxx:359
 TTree.cxx:360
 TTree.cxx:361
 TTree.cxx:362
 TTree.cxx:363
 TTree.cxx:364
 TTree.cxx:365
 TTree.cxx:366
 TTree.cxx:367
 TTree.cxx:368
 TTree.cxx:369
 TTree.cxx:370
 TTree.cxx:371
 TTree.cxx:372
 TTree.cxx:373
 TTree.cxx:374
 TTree.cxx:375
 TTree.cxx:376
 TTree.cxx:377
 TTree.cxx:378
 TTree.cxx:379
 TTree.cxx:380
 TTree.cxx:381
 TTree.cxx:382
 TTree.cxx:383
 TTree.cxx:384
 TTree.cxx:385
 TTree.cxx:386
 TTree.cxx:387
 TTree.cxx:388
 TTree.cxx:389
 TTree.cxx:390
 TTree.cxx:391
 TTree.cxx:392
 TTree.cxx:393
 TTree.cxx:394
 TTree.cxx:395
 TTree.cxx:396
 TTree.cxx:397
 TTree.cxx:398
 TTree.cxx:399
 TTree.cxx:400
 TTree.cxx:401
 TTree.cxx:402
 TTree.cxx:403
 TTree.cxx:404
 TTree.cxx:405
 TTree.cxx:406
 TTree.cxx:407
 TTree.cxx:408
 TTree.cxx:409
 TTree.cxx:410
 TTree.cxx:411
 TTree.cxx:412
 TTree.cxx:413
 TTree.cxx:414
 TTree.cxx:415
 TTree.cxx:416
 TTree.cxx:417
 TTree.cxx:418
 TTree.cxx:419
 TTree.cxx:420
 TTree.cxx:421
 TTree.cxx:422
 TTree.cxx:423
 TTree.cxx:424
 TTree.cxx:425
 TTree.cxx:426
 TTree.cxx:427
 TTree.cxx:428
 TTree.cxx:429
 TTree.cxx:430
 TTree.cxx:431
 TTree.cxx:432
 TTree.cxx:433
 TTree.cxx:434
 TTree.cxx:435
 TTree.cxx:436
 TTree.cxx:437
 TTree.cxx:438
 TTree.cxx:439
 TTree.cxx:440
 TTree.cxx:441
 TTree.cxx:442
 TTree.cxx:443
 TTree.cxx:444
 TTree.cxx:445
 TTree.cxx:446
 TTree.cxx:447
 TTree.cxx:448
 TTree.cxx:449
 TTree.cxx:450
 TTree.cxx:451
 TTree.cxx:452
 TTree.cxx:453
 TTree.cxx:454
 TTree.cxx:455
 TTree.cxx:456
 TTree.cxx:457
 TTree.cxx:458
 TTree.cxx:459
 TTree.cxx:460
 TTree.cxx:461
 TTree.cxx:462
 TTree.cxx:463
 TTree.cxx:464
 TTree.cxx:465
 TTree.cxx:466
 TTree.cxx:467
 TTree.cxx:468
 TTree.cxx:469
 TTree.cxx:470
 TTree.cxx:471
 TTree.cxx:472
 TTree.cxx:473
 TTree.cxx:474
 TTree.cxx:475
 TTree.cxx:476
 TTree.cxx:477
 TTree.cxx:478
 TTree.cxx:479
 TTree.cxx:480
 TTree.cxx:481
 TTree.cxx:482
 TTree.cxx:483
 TTree.cxx:484
 TTree.cxx:485
 TTree.cxx:486
 TTree.cxx:487
 TTree.cxx:488
 TTree.cxx:489
 TTree.cxx:490
 TTree.cxx:491
 TTree.cxx:492
 TTree.cxx:493
 TTree.cxx:494
 TTree.cxx:495
 TTree.cxx:496
 TTree.cxx:497
 TTree.cxx:498
 TTree.cxx:499
 TTree.cxx:500
 TTree.cxx:501
 TTree.cxx:502
 TTree.cxx:503
 TTree.cxx:504
 TTree.cxx:505
 TTree.cxx:506
 TTree.cxx:507
 TTree.cxx:508
 TTree.cxx:509
 TTree.cxx:510
 TTree.cxx:511
 TTree.cxx:512
 TTree.cxx:513
 TTree.cxx:514
 TTree.cxx:515
 TTree.cxx:516
 TTree.cxx:517
 TTree.cxx:518
 TTree.cxx:519
 TTree.cxx:520
 TTree.cxx:521
 TTree.cxx:522
 TTree.cxx:523
 TTree.cxx:524
 TTree.cxx:525
 TTree.cxx:526
 TTree.cxx:527
 TTree.cxx:528
 TTree.cxx:529
 TTree.cxx:530
 TTree.cxx:531
 TTree.cxx:532
 TTree.cxx:533
 TTree.cxx:534
 TTree.cxx:535
 TTree.cxx:536
 TTree.cxx:537
 TTree.cxx:538
 TTree.cxx:539
 TTree.cxx:540
 TTree.cxx:541
 TTree.cxx:542
 TTree.cxx:543
 TTree.cxx:544
 TTree.cxx:545
 TTree.cxx:546
 TTree.cxx:547
 TTree.cxx:548
 TTree.cxx:549
 TTree.cxx:550
 TTree.cxx:551
 TTree.cxx:552
 TTree.cxx:553
 TTree.cxx:554
 TTree.cxx:555
 TTree.cxx:556
 TTree.cxx:557
 TTree.cxx:558
 TTree.cxx:559
 TTree.cxx:560
 TTree.cxx:561
 TTree.cxx:562
 TTree.cxx:563
 TTree.cxx:564
 TTree.cxx:565
 TTree.cxx:566
 TTree.cxx:567
 TTree.cxx:568
 TTree.cxx:569
 TTree.cxx:570
 TTree.cxx:571
 TTree.cxx:572
 TTree.cxx:573
 TTree.cxx:574
 TTree.cxx:575
 TTree.cxx:576
 TTree.cxx:577
 TTree.cxx:578
 TTree.cxx:579
 TTree.cxx:580
 TTree.cxx:581
 TTree.cxx:582
 TTree.cxx:583
 TTree.cxx:584
 TTree.cxx:585
 TTree.cxx:586
 TTree.cxx:587
 TTree.cxx:588
 TTree.cxx:589
 TTree.cxx:590
 TTree.cxx:591
 TTree.cxx:592
 TTree.cxx:593
 TTree.cxx:594
 TTree.cxx:595
 TTree.cxx:596
 TTree.cxx:597
 TTree.cxx:598
 TTree.cxx:599
 TTree.cxx:600
 TTree.cxx:601
 TTree.cxx:602
 TTree.cxx:603
 TTree.cxx:604
 TTree.cxx:605
 TTree.cxx:606
 TTree.cxx:607
 TTree.cxx:608
 TTree.cxx:609
 TTree.cxx:610
 TTree.cxx:611
 TTree.cxx:612
 TTree.cxx:613
 TTree.cxx:614
 TTree.cxx:615
 TTree.cxx:616
 TTree.cxx:617
 TTree.cxx:618
 TTree.cxx:619
 TTree.cxx:620
 TTree.cxx:621
 TTree.cxx:622
 TTree.cxx:623
 TTree.cxx:624
 TTree.cxx:625
 TTree.cxx:626
 TTree.cxx:627
 TTree.cxx:628
 TTree.cxx:629
 TTree.cxx:630
 TTree.cxx:631
 TTree.cxx:632
 TTree.cxx:633
 TTree.cxx:634
 TTree.cxx:635
 TTree.cxx:636
 TTree.cxx:637
 TTree.cxx:638
 TTree.cxx:639
 TTree.cxx:640
 TTree.cxx:641
 TTree.cxx:642
 TTree.cxx:643
 TTree.cxx:644
 TTree.cxx:645
 TTree.cxx:646
 TTree.cxx:647
 TTree.cxx:648
 TTree.cxx:649
 TTree.cxx:650
 TTree.cxx:651
 TTree.cxx:652
 TTree.cxx:653
 TTree.cxx:654
 TTree.cxx:655
 TTree.cxx:656
 TTree.cxx:657
 TTree.cxx:658
 TTree.cxx:659
 TTree.cxx:660
 TTree.cxx:661
 TTree.cxx:662
 TTree.cxx:663
 TTree.cxx:664
 TTree.cxx:665
 TTree.cxx:666
 TTree.cxx:667
 TTree.cxx:668
 TTree.cxx:669
 TTree.cxx:670
 TTree.cxx:671
 TTree.cxx:672
 TTree.cxx:673
 TTree.cxx:674
 TTree.cxx:675
 TTree.cxx:676
 TTree.cxx:677
 TTree.cxx:678
 TTree.cxx:679
 TTree.cxx:680
 TTree.cxx:681
 TTree.cxx:682
 TTree.cxx:683
 TTree.cxx:684
 TTree.cxx:685
 TTree.cxx:686
 TTree.cxx:687
 TTree.cxx:688
 TTree.cxx:689
 TTree.cxx:690
 TTree.cxx:691
 TTree.cxx:692
 TTree.cxx:693
 TTree.cxx:694
 TTree.cxx:695
 TTree.cxx:696
 TTree.cxx:697
 TTree.cxx:698
 TTree.cxx:699
 TTree.cxx:700
 TTree.cxx:701
 TTree.cxx:702
 TTree.cxx:703
 TTree.cxx:704
 TTree.cxx:705
 TTree.cxx:706
 TTree.cxx:707
 TTree.cxx:708
 TTree.cxx:709
 TTree.cxx:710
 TTree.cxx:711
 TTree.cxx:712
 TTree.cxx:713
 TTree.cxx:714
 TTree.cxx:715
 TTree.cxx:716
 TTree.cxx:717
 TTree.cxx:718
 TTree.cxx:719
 TTree.cxx:720
 TTree.cxx:721
 TTree.cxx:722
 TTree.cxx:723
 TTree.cxx:724
 TTree.cxx:725
 TTree.cxx:726
 TTree.cxx:727
 TTree.cxx:728
 TTree.cxx:729
 TTree.cxx:730
 TTree.cxx:731
 TTree.cxx:732
 TTree.cxx:733
 TTree.cxx:734
 TTree.cxx:735
 TTree.cxx:736
 TTree.cxx:737
 TTree.cxx:738
 TTree.cxx:739
 TTree.cxx:740
 TTree.cxx:741
 TTree.cxx:742
 TTree.cxx:743
 TTree.cxx:744
 TTree.cxx:745
 TTree.cxx:746
 TTree.cxx:747
 TTree.cxx:748
 TTree.cxx:749
 TTree.cxx:750
 TTree.cxx:751
 TTree.cxx:752
 TTree.cxx:753
 TTree.cxx:754
 TTree.cxx:755
 TTree.cxx:756
 TTree.cxx:757
 TTree.cxx:758
 TTree.cxx:759
 TTree.cxx:760
 TTree.cxx:761
 TTree.cxx:762
 TTree.cxx:763
 TTree.cxx:764
 TTree.cxx:765
 TTree.cxx:766
 TTree.cxx:767
 TTree.cxx:768
 TTree.cxx:769
 TTree.cxx:770
 TTree.cxx:771
 TTree.cxx:772
 TTree.cxx:773
 TTree.cxx:774
 TTree.cxx:775
 TTree.cxx:776
 TTree.cxx:777
 TTree.cxx:778
 TTree.cxx:779
 TTree.cxx:780
 TTree.cxx:781
 TTree.cxx:782
 TTree.cxx:783
 TTree.cxx:784
 TTree.cxx:785
 TTree.cxx:786
 TTree.cxx:787
 TTree.cxx:788
 TTree.cxx:789
 TTree.cxx:790
 TTree.cxx:791
 TTree.cxx:792
 TTree.cxx:793
 TTree.cxx:794
 TTree.cxx:795
 TTree.cxx:796
 TTree.cxx:797
 TTree.cxx:798
 TTree.cxx:799
 TTree.cxx:800
 TTree.cxx:801
 TTree.cxx:802
 TTree.cxx:803
 TTree.cxx:804
 TTree.cxx:805
 TTree.cxx:806
 TTree.cxx:807
 TTree.cxx:808
 TTree.cxx:809
 TTree.cxx:810
 TTree.cxx:811
 TTree.cxx:812
 TTree.cxx:813
 TTree.cxx:814
 TTree.cxx:815
 TTree.cxx:816
 TTree.cxx:817
 TTree.cxx:818
 TTree.cxx:819
 TTree.cxx:820
 TTree.cxx:821
 TTree.cxx:822
 TTree.cxx:823
 TTree.cxx:824
 TTree.cxx:825
 TTree.cxx:826
 TTree.cxx:827
 TTree.cxx:828
 TTree.cxx:829
 TTree.cxx:830
 TTree.cxx:831
 TTree.cxx:832
 TTree.cxx:833
 TTree.cxx:834
 TTree.cxx:835
 TTree.cxx:836
 TTree.cxx:837
 TTree.cxx:838
 TTree.cxx:839
 TTree.cxx:840
 TTree.cxx:841
 TTree.cxx:842
 TTree.cxx:843
 TTree.cxx:844
 TTree.cxx:845
 TTree.cxx:846
 TTree.cxx:847
 TTree.cxx:848
 TTree.cxx:849
 TTree.cxx:850
 TTree.cxx:851
 TTree.cxx:852
 TTree.cxx:853
 TTree.cxx:854
 TTree.cxx:855
 TTree.cxx:856
 TTree.cxx:857
 TTree.cxx:858
 TTree.cxx:859
 TTree.cxx:860
 TTree.cxx:861
 TTree.cxx:862
 TTree.cxx:863
 TTree.cxx:864
 TTree.cxx:865
 TTree.cxx:866
 TTree.cxx:867
 TTree.cxx:868
 TTree.cxx:869
 TTree.cxx:870
 TTree.cxx:871
 TTree.cxx:872
 TTree.cxx:873
 TTree.cxx:874
 TTree.cxx:875
 TTree.cxx:876
 TTree.cxx:877
 TTree.cxx:878
 TTree.cxx:879
 TTree.cxx:880
 TTree.cxx:881
 TTree.cxx:882
 TTree.cxx:883
 TTree.cxx:884
 TTree.cxx:885
 TTree.cxx:886
 TTree.cxx:887
 TTree.cxx:888
 TTree.cxx:889
 TTree.cxx:890
 TTree.cxx:891
 TTree.cxx:892
 TTree.cxx:893
 TTree.cxx:894
 TTree.cxx:895
 TTree.cxx:896
 TTree.cxx:897
 TTree.cxx:898
 TTree.cxx:899
 TTree.cxx:900
 TTree.cxx:901
 TTree.cxx:902
 TTree.cxx:903
 TTree.cxx:904
 TTree.cxx:905
 TTree.cxx:906
 TTree.cxx:907
 TTree.cxx:908
 TTree.cxx:909
 TTree.cxx:910
 TTree.cxx:911
 TTree.cxx:912
 TTree.cxx:913
 TTree.cxx:914
 TTree.cxx:915
 TTree.cxx:916
 TTree.cxx:917
 TTree.cxx:918
 TTree.cxx:919
 TTree.cxx:920
 TTree.cxx:921
 TTree.cxx:922
 TTree.cxx:923
 TTree.cxx:924
 TTree.cxx:925
 TTree.cxx:926
 TTree.cxx:927
 TTree.cxx:928
 TTree.cxx:929
 TTree.cxx:930
 TTree.cxx:931
 TTree.cxx:932
 TTree.cxx:933
 TTree.cxx:934
 TTree.cxx:935
 TTree.cxx:936
 TTree.cxx:937
 TTree.cxx:938
 TTree.cxx:939
 TTree.cxx:940
 TTree.cxx:941
 TTree.cxx:942
 TTree.cxx:943
 TTree.cxx:944
 TTree.cxx:945
 TTree.cxx:946
 TTree.cxx:947
 TTree.cxx:948
 TTree.cxx:949
 TTree.cxx:950
 TTree.cxx:951
 TTree.cxx:952
 TTree.cxx:953
 TTree.cxx:954
 TTree.cxx:955
 TTree.cxx:956
 TTree.cxx:957
 TTree.cxx:958
 TTree.cxx:959
 TTree.cxx:960
 TTree.cxx:961
 TTree.cxx:962
 TTree.cxx:963
 TTree.cxx:964
 TTree.cxx:965
 TTree.cxx:966
 TTree.cxx:967
 TTree.cxx:968
 TTree.cxx:969
 TTree.cxx:970
 TTree.cxx:971
 TTree.cxx:972
 TTree.cxx:973
 TTree.cxx:974
 TTree.cxx:975
 TTree.cxx:976
 TTree.cxx:977
 TTree.cxx:978
 TTree.cxx:979
 TTree.cxx:980
 TTree.cxx:981
 TTree.cxx:982
 TTree.cxx:983
 TTree.cxx:984
 TTree.cxx:985
 TTree.cxx:986
 TTree.cxx:987
 TTree.cxx:988
 TTree.cxx:989
 TTree.cxx:990
 TTree.cxx:991
 TTree.cxx:992
 TTree.cxx:993
 TTree.cxx:994
 TTree.cxx:995
 TTree.cxx:996
 TTree.cxx:997
 TTree.cxx:998
 TTree.cxx:999
 TTree.cxx:1000
 TTree.cxx:1001
 TTree.cxx:1002
 TTree.cxx:1003
 TTree.cxx:1004
 TTree.cxx:1005
 TTree.cxx:1006
 TTree.cxx:1007
 TTree.cxx:1008
 TTree.cxx:1009
 TTree.cxx:1010
 TTree.cxx:1011
 TTree.cxx:1012
 TTree.cxx:1013
 TTree.cxx:1014
 TTree.cxx:1015
 TTree.cxx:1016
 TTree.cxx:1017
 TTree.cxx:1018
 TTree.cxx:1019
 TTree.cxx:1020
 TTree.cxx:1021
 TTree.cxx:1022
 TTree.cxx:1023
 TTree.cxx:1024
 TTree.cxx:1025
 TTree.cxx:1026
 TTree.cxx:1027
 TTree.cxx:1028
 TTree.cxx:1029
 TTree.cxx:1030
 TTree.cxx:1031
 TTree.cxx:1032
 TTree.cxx:1033
 TTree.cxx:1034
 TTree.cxx:1035
 TTree.cxx:1036
 TTree.cxx:1037
 TTree.cxx:1038
 TTree.cxx:1039
 TTree.cxx:1040
 TTree.cxx:1041
 TTree.cxx:1042
 TTree.cxx:1043
 TTree.cxx:1044
 TTree.cxx:1045
 TTree.cxx:1046
 TTree.cxx:1047
 TTree.cxx:1048
 TTree.cxx:1049
 TTree.cxx:1050
 TTree.cxx:1051
 TTree.cxx:1052
 TTree.cxx:1053
 TTree.cxx:1054
 TTree.cxx:1055
 TTree.cxx:1056
 TTree.cxx:1057
 TTree.cxx:1058
 TTree.cxx:1059
 TTree.cxx:1060
 TTree.cxx:1061
 TTree.cxx:1062
 TTree.cxx:1063
 TTree.cxx:1064
 TTree.cxx:1065
 TTree.cxx:1066
 TTree.cxx:1067
 TTree.cxx:1068
 TTree.cxx:1069
 TTree.cxx:1070
 TTree.cxx:1071
 TTree.cxx:1072
 TTree.cxx:1073
 TTree.cxx:1074
 TTree.cxx:1075
 TTree.cxx:1076
 TTree.cxx:1077
 TTree.cxx:1078
 TTree.cxx:1079
 TTree.cxx:1080
 TTree.cxx:1081
 TTree.cxx:1082
 TTree.cxx:1083
 TTree.cxx:1084
 TTree.cxx:1085
 TTree.cxx:1086
 TTree.cxx:1087
 TTree.cxx:1088
 TTree.cxx:1089
 TTree.cxx:1090
 TTree.cxx:1091
 TTree.cxx:1092
 TTree.cxx:1093
 TTree.cxx:1094
 TTree.cxx:1095
 TTree.cxx:1096
 TTree.cxx:1097
 TTree.cxx:1098
 TTree.cxx:1099
 TTree.cxx:1100
 TTree.cxx:1101
 TTree.cxx:1102
 TTree.cxx:1103
 TTree.cxx:1104
 TTree.cxx:1105
 TTree.cxx:1106
 TTree.cxx:1107
 TTree.cxx:1108
 TTree.cxx:1109
 TTree.cxx:1110
 TTree.cxx:1111
 TTree.cxx:1112
 TTree.cxx:1113
 TTree.cxx:1114
 TTree.cxx:1115
 TTree.cxx:1116
 TTree.cxx:1117
 TTree.cxx:1118
 TTree.cxx:1119
 TTree.cxx:1120
 TTree.cxx:1121
 TTree.cxx:1122
 TTree.cxx:1123
 TTree.cxx:1124
 TTree.cxx:1125
 TTree.cxx:1126
 TTree.cxx:1127
 TTree.cxx:1128
 TTree.cxx:1129
 TTree.cxx:1130
 TTree.cxx:1131
 TTree.cxx:1132
 TTree.cxx:1133
 TTree.cxx:1134
 TTree.cxx:1135
 TTree.cxx:1136
 TTree.cxx:1137
 TTree.cxx:1138
 TTree.cxx:1139
 TTree.cxx:1140
 TTree.cxx:1141
 TTree.cxx:1142
 TTree.cxx:1143
 TTree.cxx:1144
 TTree.cxx:1145
 TTree.cxx:1146
 TTree.cxx:1147
 TTree.cxx:1148
 TTree.cxx:1149
 TTree.cxx:1150
 TTree.cxx:1151
 TTree.cxx:1152
 TTree.cxx:1153
 TTree.cxx:1154
 TTree.cxx:1155
 TTree.cxx:1156
 TTree.cxx:1157
 TTree.cxx:1158
 TTree.cxx:1159
 TTree.cxx:1160
 TTree.cxx:1161
 TTree.cxx:1162
 TTree.cxx:1163
 TTree.cxx:1164
 TTree.cxx:1165
 TTree.cxx:1166
 TTree.cxx:1167
 TTree.cxx:1168
 TTree.cxx:1169
 TTree.cxx:1170
 TTree.cxx:1171
 TTree.cxx:1172
 TTree.cxx:1173
 TTree.cxx:1174
 TTree.cxx:1175
 TTree.cxx:1176
 TTree.cxx:1177
 TTree.cxx:1178
 TTree.cxx:1179
 TTree.cxx:1180
 TTree.cxx:1181
 TTree.cxx:1182
 TTree.cxx:1183
 TTree.cxx:1184
 TTree.cxx:1185
 TTree.cxx:1186
 TTree.cxx:1187
 TTree.cxx:1188
 TTree.cxx:1189
 TTree.cxx:1190
 TTree.cxx:1191
 TTree.cxx:1192
 TTree.cxx:1193
 TTree.cxx:1194
 TTree.cxx:1195
 TTree.cxx:1196
 TTree.cxx:1197
 TTree.cxx:1198
 TTree.cxx:1199
 TTree.cxx:1200
 TTree.cxx:1201
 TTree.cxx:1202
 TTree.cxx:1203
 TTree.cxx:1204
 TTree.cxx:1205
 TTree.cxx:1206
 TTree.cxx:1207
 TTree.cxx:1208
 TTree.cxx:1209
 TTree.cxx:1210
 TTree.cxx:1211
 TTree.cxx:1212
 TTree.cxx:1213
 TTree.cxx:1214
 TTree.cxx:1215
 TTree.cxx:1216
 TTree.cxx:1217
 TTree.cxx:1218
 TTree.cxx:1219
 TTree.cxx:1220
 TTree.cxx:1221
 TTree.cxx:1222
 TTree.cxx:1223
 TTree.cxx:1224
 TTree.cxx:1225
 TTree.cxx:1226
 TTree.cxx:1227
 TTree.cxx:1228
 TTree.cxx:1229
 TTree.cxx:1230
 TTree.cxx:1231
 TTree.cxx:1232
 TTree.cxx:1233
 TTree.cxx:1234
 TTree.cxx:1235
 TTree.cxx:1236
 TTree.cxx:1237
 TTree.cxx:1238
 TTree.cxx:1239
 TTree.cxx:1240
 TTree.cxx:1241
 TTree.cxx:1242
 TTree.cxx:1243
 TTree.cxx:1244
 TTree.cxx:1245
 TTree.cxx:1246
 TTree.cxx:1247
 TTree.cxx:1248
 TTree.cxx:1249
 TTree.cxx:1250
 TTree.cxx:1251
 TTree.cxx:1252
 TTree.cxx:1253
 TTree.cxx:1254
 TTree.cxx:1255
 TTree.cxx:1256
 TTree.cxx:1257
 TTree.cxx:1258
 TTree.cxx:1259
 TTree.cxx:1260
 TTree.cxx:1261
 TTree.cxx:1262
 TTree.cxx:1263
 TTree.cxx:1264
 TTree.cxx:1265
 TTree.cxx:1266
 TTree.cxx:1267
 TTree.cxx:1268
 TTree.cxx:1269
 TTree.cxx:1270
 TTree.cxx:1271
 TTree.cxx:1272
 TTree.cxx:1273
 TTree.cxx:1274
 TTree.cxx:1275
 TTree.cxx:1276
 TTree.cxx:1277
 TTree.cxx:1278
 TTree.cxx:1279
 TTree.cxx:1280
 TTree.cxx:1281
 TTree.cxx:1282
 TTree.cxx:1283
 TTree.cxx:1284
 TTree.cxx:1285
 TTree.cxx:1286
 TTree.cxx:1287
 TTree.cxx:1288
 TTree.cxx:1289
 TTree.cxx:1290
 TTree.cxx:1291
 TTree.cxx:1292
 TTree.cxx:1293
 TTree.cxx:1294
 TTree.cxx:1295
 TTree.cxx:1296
 TTree.cxx:1297
 TTree.cxx:1298
 TTree.cxx:1299
 TTree.cxx:1300
 TTree.cxx:1301
 TTree.cxx:1302
 TTree.cxx:1303
 TTree.cxx:1304
 TTree.cxx:1305
 TTree.cxx:1306
 TTree.cxx:1307
 TTree.cxx:1308
 TTree.cxx:1309
 TTree.cxx:1310
 TTree.cxx:1311
 TTree.cxx:1312
 TTree.cxx:1313
 TTree.cxx:1314
 TTree.cxx:1315
 TTree.cxx:1316
 TTree.cxx:1317
 TTree.cxx:1318
 TTree.cxx:1319
 TTree.cxx:1320
 TTree.cxx:1321
 TTree.cxx:1322
 TTree.cxx:1323
 TTree.cxx:1324
 TTree.cxx:1325
 TTree.cxx:1326
 TTree.cxx:1327
 TTree.cxx:1328
 TTree.cxx:1329
 TTree.cxx:1330
 TTree.cxx:1331
 TTree.cxx:1332
 TTree.cxx:1333
 TTree.cxx:1334
 TTree.cxx:1335
 TTree.cxx:1336
 TTree.cxx:1337
 TTree.cxx:1338
 TTree.cxx:1339
 TTree.cxx:1340
 TTree.cxx:1341
 TTree.cxx:1342
 TTree.cxx:1343
 TTree.cxx:1344
 TTree.cxx:1345
 TTree.cxx:1346
 TTree.cxx:1347
 TTree.cxx:1348
 TTree.cxx:1349
 TTree.cxx:1350
 TTree.cxx:1351
 TTree.cxx:1352
 TTree.cxx:1353
 TTree.cxx:1354
 TTree.cxx:1355
 TTree.cxx:1356
 TTree.cxx:1357
 TTree.cxx:1358
 TTree.cxx:1359
 TTree.cxx:1360
 TTree.cxx:1361
 TTree.cxx:1362
 TTree.cxx:1363
 TTree.cxx:1364
 TTree.cxx:1365
 TTree.cxx:1366
 TTree.cxx:1367
 TTree.cxx:1368
 TTree.cxx:1369
 TTree.cxx:1370
 TTree.cxx:1371
 TTree.cxx:1372
 TTree.cxx:1373
 TTree.cxx:1374
 TTree.cxx:1375
 TTree.cxx:1376
 TTree.cxx:1377
 TTree.cxx:1378
 TTree.cxx:1379
 TTree.cxx:1380
 TTree.cxx:1381
 TTree.cxx:1382
 TTree.cxx:1383
 TTree.cxx:1384
 TTree.cxx:1385
 TTree.cxx:1386
 TTree.cxx:1387
 TTree.cxx:1388
 TTree.cxx:1389
 TTree.cxx:1390
 TTree.cxx:1391
 TTree.cxx:1392
 TTree.cxx:1393
 TTree.cxx:1394
 TTree.cxx:1395
 TTree.cxx:1396
 TTree.cxx:1397
 TTree.cxx:1398
 TTree.cxx:1399
 TTree.cxx:1400
 TTree.cxx:1401
 TTree.cxx:1402
 TTree.cxx:1403
 TTree.cxx:1404
 TTree.cxx:1405
 TTree.cxx:1406
 TTree.cxx:1407
 TTree.cxx:1408
 TTree.cxx:1409
 TTree.cxx:1410
 TTree.cxx:1411
 TTree.cxx:1412
 TTree.cxx:1413
 TTree.cxx:1414
 TTree.cxx:1415
 TTree.cxx:1416
 TTree.cxx:1417
 TTree.cxx:1418
 TTree.cxx:1419
 TTree.cxx:1420
 TTree.cxx:1421
 TTree.cxx:1422
 TTree.cxx:1423
 TTree.cxx:1424
 TTree.cxx:1425
 TTree.cxx:1426
 TTree.cxx:1427
 TTree.cxx:1428
 TTree.cxx:1429
 TTree.cxx:1430
 TTree.cxx:1431
 TTree.cxx:1432
 TTree.cxx:1433
 TTree.cxx:1434
 TTree.cxx:1435
 TTree.cxx:1436
 TTree.cxx:1437
 TTree.cxx:1438
 TTree.cxx:1439
 TTree.cxx:1440
 TTree.cxx:1441
 TTree.cxx:1442
 TTree.cxx:1443
 TTree.cxx:1444
 TTree.cxx:1445
 TTree.cxx:1446
 TTree.cxx:1447
 TTree.cxx:1448
 TTree.cxx:1449
 TTree.cxx:1450
 TTree.cxx:1451
 TTree.cxx:1452
 TTree.cxx:1453
 TTree.cxx:1454
 TTree.cxx:1455
 TTree.cxx:1456
 TTree.cxx:1457
 TTree.cxx:1458
 TTree.cxx:1459
 TTree.cxx:1460
 TTree.cxx:1461
 TTree.cxx:1462
 TTree.cxx:1463
 TTree.cxx:1464
 TTree.cxx:1465
 TTree.cxx:1466
 TTree.cxx:1467
 TTree.cxx:1468
 TTree.cxx:1469
 TTree.cxx:1470
 TTree.cxx:1471
 TTree.cxx:1472
 TTree.cxx:1473
 TTree.cxx:1474
 TTree.cxx:1475
 TTree.cxx:1476
 TTree.cxx:1477
 TTree.cxx:1478
 TTree.cxx:1479
 TTree.cxx:1480
 TTree.cxx:1481
 TTree.cxx:1482
 TTree.cxx:1483
 TTree.cxx:1484
 TTree.cxx:1485
 TTree.cxx:1486
 TTree.cxx:1487
 TTree.cxx:1488
 TTree.cxx:1489
 TTree.cxx:1490
 TTree.cxx:1491
 TTree.cxx:1492
 TTree.cxx:1493
 TTree.cxx:1494
 TTree.cxx:1495
 TTree.cxx:1496
 TTree.cxx:1497
 TTree.cxx:1498
 TTree.cxx:1499
 TTree.cxx:1500
 TTree.cxx:1501
 TTree.cxx:1502
 TTree.cxx:1503
 TTree.cxx:1504
 TTree.cxx:1505
 TTree.cxx:1506
 TTree.cxx:1507
 TTree.cxx:1508
 TTree.cxx:1509
 TTree.cxx:1510
 TTree.cxx:1511
 TTree.cxx:1512
 TTree.cxx:1513
 TTree.cxx:1514
 TTree.cxx:1515
 TTree.cxx:1516
 TTree.cxx:1517
 TTree.cxx:1518
 TTree.cxx:1519
 TTree.cxx:1520
 TTree.cxx:1521
 TTree.cxx:1522
 TTree.cxx:1523
 TTree.cxx:1524
 TTree.cxx:1525
 TTree.cxx:1526
 TTree.cxx:1527
 TTree.cxx:1528
 TTree.cxx:1529
 TTree.cxx:1530
 TTree.cxx:1531
 TTree.cxx:1532
 TTree.cxx:1533
 TTree.cxx:1534
 TTree.cxx:1535
 TTree.cxx:1536
 TTree.cxx:1537
 TTree.cxx:1538
 TTree.cxx:1539
 TTree.cxx:1540
 TTree.cxx:1541
 TTree.cxx:1542
 TTree.cxx:1543
 TTree.cxx:1544
 TTree.cxx:1545
 TTree.cxx:1546
 TTree.cxx:1547
 TTree.cxx:1548
 TTree.cxx:1549
 TTree.cxx:1550
 TTree.cxx:1551
 TTree.cxx:1552
 TTree.cxx:1553
 TTree.cxx:1554
 TTree.cxx:1555
 TTree.cxx:1556
 TTree.cxx:1557
 TTree.cxx:1558
 TTree.cxx:1559
 TTree.cxx:1560
 TTree.cxx:1561
 TTree.cxx:1562
 TTree.cxx:1563
 TTree.cxx:1564
 TTree.cxx:1565
 TTree.cxx:1566
 TTree.cxx:1567
 TTree.cxx:1568
 TTree.cxx:1569
 TTree.cxx:1570
 TTree.cxx:1571
 TTree.cxx:1572
 TTree.cxx:1573
 TTree.cxx:1574
 TTree.cxx:1575
 TTree.cxx:1576
 TTree.cxx:1577
 TTree.cxx:1578
 TTree.cxx:1579
 TTree.cxx:1580
 TTree.cxx:1581
 TTree.cxx:1582
 TTree.cxx:1583
 TTree.cxx:1584
 TTree.cxx:1585
 TTree.cxx:1586
 TTree.cxx:1587
 TTree.cxx:1588
 TTree.cxx:1589
 TTree.cxx:1590
 TTree.cxx:1591
 TTree.cxx:1592
 TTree.cxx:1593
 TTree.cxx:1594
 TTree.cxx:1595
 TTree.cxx:1596
 TTree.cxx:1597
 TTree.cxx:1598
 TTree.cxx:1599
 TTree.cxx:1600
 TTree.cxx:1601
 TTree.cxx:1602
 TTree.cxx:1603
 TTree.cxx:1604
 TTree.cxx:1605
 TTree.cxx:1606
 TTree.cxx:1607
 TTree.cxx:1608
 TTree.cxx:1609
 TTree.cxx:1610
 TTree.cxx:1611
 TTree.cxx:1612
 TTree.cxx:1613
 TTree.cxx:1614
 TTree.cxx:1615
 TTree.cxx:1616
 TTree.cxx:1617
 TTree.cxx:1618
 TTree.cxx:1619
 TTree.cxx:1620
 TTree.cxx:1621
 TTree.cxx:1622
 TTree.cxx:1623
 TTree.cxx:1624
 TTree.cxx:1625
 TTree.cxx:1626
 TTree.cxx:1627
 TTree.cxx:1628
 TTree.cxx:1629
 TTree.cxx:1630
 TTree.cxx:1631
 TTree.cxx:1632
 TTree.cxx:1633
 TTree.cxx:1634
 TTree.cxx:1635
 TTree.cxx:1636
 TTree.cxx:1637
 TTree.cxx:1638
 TTree.cxx:1639
 TTree.cxx:1640
 TTree.cxx:1641
 TTree.cxx:1642
 TTree.cxx:1643
 TTree.cxx:1644
 TTree.cxx:1645
 TTree.cxx:1646
 TTree.cxx:1647
 TTree.cxx:1648
 TTree.cxx:1649
 TTree.cxx:1650
 TTree.cxx:1651
 TTree.cxx:1652
 TTree.cxx:1653
 TTree.cxx:1654
 TTree.cxx:1655
 TTree.cxx:1656
 TTree.cxx:1657
 TTree.cxx:1658
 TTree.cxx:1659
 TTree.cxx:1660
 TTree.cxx:1661
 TTree.cxx:1662
 TTree.cxx:1663
 TTree.cxx:1664
 TTree.cxx:1665
 TTree.cxx:1666
 TTree.cxx:1667
 TTree.cxx:1668
 TTree.cxx:1669
 TTree.cxx:1670
 TTree.cxx:1671
 TTree.cxx:1672
 TTree.cxx:1673
 TTree.cxx:1674
 TTree.cxx:1675
 TTree.cxx:1676
 TTree.cxx:1677
 TTree.cxx:1678
 TTree.cxx:1679
 TTree.cxx:1680
 TTree.cxx:1681
 TTree.cxx:1682
 TTree.cxx:1683
 TTree.cxx:1684
 TTree.cxx:1685
 TTree.cxx:1686
 TTree.cxx:1687
 TTree.cxx:1688
 TTree.cxx:1689
 TTree.cxx:1690
 TTree.cxx:1691
 TTree.cxx:1692
 TTree.cxx:1693
 TTree.cxx:1694
 TTree.cxx:1695
 TTree.cxx:1696
 TTree.cxx:1697
 TTree.cxx:1698
 TTree.cxx:1699
 TTree.cxx:1700
 TTree.cxx:1701
 TTree.cxx:1702
 TTree.cxx:1703
 TTree.cxx:1704
 TTree.cxx:1705
 TTree.cxx:1706
 TTree.cxx:1707
 TTree.cxx:1708
 TTree.cxx:1709
 TTree.cxx:1710
 TTree.cxx:1711
 TTree.cxx:1712
 TTree.cxx:1713
 TTree.cxx:1714
 TTree.cxx:1715
 TTree.cxx:1716
 TTree.cxx:1717
 TTree.cxx:1718
 TTree.cxx:1719
 TTree.cxx:1720
 TTree.cxx:1721
 TTree.cxx:1722
 TTree.cxx:1723
 TTree.cxx:1724
 TTree.cxx:1725
 TTree.cxx:1726
 TTree.cxx:1727
 TTree.cxx:1728
 TTree.cxx:1729
 TTree.cxx:1730
 TTree.cxx:1731
 TTree.cxx:1732
 TTree.cxx:1733
 TTree.cxx:1734
 TTree.cxx:1735
 TTree.cxx:1736
 TTree.cxx:1737
 TTree.cxx:1738
 TTree.cxx:1739
 TTree.cxx:1740
 TTree.cxx:1741
 TTree.cxx:1742
 TTree.cxx:1743
 TTree.cxx:1744
 TTree.cxx:1745
 TTree.cxx:1746
 TTree.cxx:1747
 TTree.cxx:1748
 TTree.cxx:1749
 TTree.cxx:1750
 TTree.cxx:1751
 TTree.cxx:1752
 TTree.cxx:1753
 TTree.cxx:1754
 TTree.cxx:1755
 TTree.cxx:1756
 TTree.cxx:1757
 TTree.cxx:1758
 TTree.cxx:1759
 TTree.cxx:1760
 TTree.cxx:1761
 TTree.cxx:1762
 TTree.cxx:1763
 TTree.cxx:1764
 TTree.cxx:1765
 TTree.cxx:1766
 TTree.cxx:1767
 TTree.cxx:1768
 TTree.cxx:1769
 TTree.cxx:1770
 TTree.cxx:1771
 TTree.cxx:1772
 TTree.cxx:1773
 TTree.cxx:1774
 TTree.cxx:1775
 TTree.cxx:1776
 TTree.cxx:1777
 TTree.cxx:1778
 TTree.cxx:1779
 TTree.cxx:1780
 TTree.cxx:1781
 TTree.cxx:1782
 TTree.cxx:1783
 TTree.cxx:1784
 TTree.cxx:1785
 TTree.cxx:1786
 TTree.cxx:1787
 TTree.cxx:1788
 TTree.cxx:1789
 TTree.cxx:1790
 TTree.cxx:1791
 TTree.cxx:1792
 TTree.cxx:1793
 TTree.cxx:1794
 TTree.cxx:1795
 TTree.cxx:1796
 TTree.cxx:1797
 TTree.cxx:1798
 TTree.cxx:1799
 TTree.cxx:1800
 TTree.cxx:1801
 TTree.cxx:1802
 TTree.cxx:1803
 TTree.cxx:1804
 TTree.cxx:1805
 TTree.cxx:1806
 TTree.cxx:1807
 TTree.cxx:1808
 TTree.cxx:1809
 TTree.cxx:1810
 TTree.cxx:1811
 TTree.cxx:1812
 TTree.cxx:1813
 TTree.cxx:1814
 TTree.cxx:1815
 TTree.cxx:1816
 TTree.cxx:1817
 TTree.cxx:1818
 TTree.cxx:1819
 TTree.cxx:1820
 TTree.cxx:1821
 TTree.cxx:1822
 TTree.cxx:1823
 TTree.cxx:1824
 TTree.cxx:1825
 TTree.cxx:1826
 TTree.cxx:1827
 TTree.cxx:1828
 TTree.cxx:1829
 TTree.cxx:1830
 TTree.cxx:1831
 TTree.cxx:1832
 TTree.cxx:1833
 TTree.cxx:1834
 TTree.cxx:1835
 TTree.cxx:1836
 TTree.cxx:1837
 TTree.cxx:1838
 TTree.cxx:1839
 TTree.cxx:1840
 TTree.cxx:1841
 TTree.cxx:1842
 TTree.cxx:1843
 TTree.cxx:1844
 TTree.cxx:1845
 TTree.cxx:1846
 TTree.cxx:1847
 TTree.cxx:1848
 TTree.cxx:1849
 TTree.cxx:1850
 TTree.cxx:1851
 TTree.cxx:1852
 TTree.cxx:1853
 TTree.cxx:1854
 TTree.cxx:1855
 TTree.cxx:1856
 TTree.cxx:1857
 TTree.cxx:1858
 TTree.cxx:1859
 TTree.cxx:1860
 TTree.cxx:1861
 TTree.cxx:1862
 TTree.cxx:1863
 TTree.cxx:1864
 TTree.cxx:1865
 TTree.cxx:1866
 TTree.cxx:1867
 TTree.cxx:1868
 TTree.cxx:1869
 TTree.cxx:1870
 TTree.cxx:1871
 TTree.cxx:1872
 TTree.cxx:1873
 TTree.cxx:1874
 TTree.cxx:1875
 TTree.cxx:1876
 TTree.cxx:1877
 TTree.cxx:1878
 TTree.cxx:1879
 TTree.cxx:1880
 TTree.cxx:1881
 TTree.cxx:1882
 TTree.cxx:1883
 TTree.cxx:1884
 TTree.cxx:1885
 TTree.cxx:1886
 TTree.cxx:1887
 TTree.cxx:1888
 TTree.cxx:1889
 TTree.cxx:1890
 TTree.cxx:1891
 TTree.cxx:1892
 TTree.cxx:1893
 TTree.cxx:1894
 TTree.cxx:1895
 TTree.cxx:1896
 TTree.cxx:1897
 TTree.cxx:1898
 TTree.cxx:1899
 TTree.cxx:1900
 TTree.cxx:1901
 TTree.cxx:1902
 TTree.cxx:1903
 TTree.cxx:1904
 TTree.cxx:1905
 TTree.cxx:1906
 TTree.cxx:1907
 TTree.cxx:1908
 TTree.cxx:1909
 TTree.cxx:1910
 TTree.cxx:1911
 TTree.cxx:1912
 TTree.cxx:1913
 TTree.cxx:1914
 TTree.cxx:1915
 TTree.cxx:1916
 TTree.cxx:1917
 TTree.cxx:1918
 TTree.cxx:1919
 TTree.cxx:1920
 TTree.cxx:1921
 TTree.cxx:1922
 TTree.cxx:1923
 TTree.cxx:1924
 TTree.cxx:1925
 TTree.cxx:1926
 TTree.cxx:1927
 TTree.cxx:1928
 TTree.cxx:1929
 TTree.cxx:1930
 TTree.cxx:1931
 TTree.cxx:1932
 TTree.cxx:1933
 TTree.cxx:1934
 TTree.cxx:1935
 TTree.cxx:1936
 TTree.cxx:1937
 TTree.cxx:1938
 TTree.cxx:1939
 TTree.cxx:1940
 TTree.cxx:1941
 TTree.cxx:1942
 TTree.cxx:1943
 TTree.cxx:1944
 TTree.cxx:1945
 TTree.cxx:1946
 TTree.cxx:1947
 TTree.cxx:1948
 TTree.cxx:1949
 TTree.cxx:1950
 TTree.cxx:1951
 TTree.cxx:1952
 TTree.cxx:1953
 TTree.cxx:1954
 TTree.cxx:1955
 TTree.cxx:1956
 TTree.cxx:1957
 TTree.cxx:1958
 TTree.cxx:1959
 TTree.cxx:1960
 TTree.cxx:1961
 TTree.cxx:1962
 TTree.cxx:1963
 TTree.cxx:1964
 TTree.cxx:1965
 TTree.cxx:1966
 TTree.cxx:1967
 TTree.cxx:1968
 TTree.cxx:1969
 TTree.cxx:1970
 TTree.cxx:1971
 TTree.cxx:1972
 TTree.cxx:1973
 TTree.cxx:1974
 TTree.cxx:1975
 TTree.cxx:1976
 TTree.cxx:1977
 TTree.cxx:1978
 TTree.cxx:1979
 TTree.cxx:1980
 TTree.cxx:1981
 TTree.cxx:1982
 TTree.cxx:1983
 TTree.cxx:1984
 TTree.cxx:1985
 TTree.cxx:1986
 TTree.cxx:1987
 TTree.cxx:1988
 TTree.cxx:1989
 TTree.cxx:1990
 TTree.cxx:1991
 TTree.cxx:1992
 TTree.cxx:1993
 TTree.cxx:1994
 TTree.cxx:1995
 TTree.cxx:1996
 TTree.cxx:1997
 TTree.cxx:1998
 TTree.cxx:1999
 TTree.cxx:2000
 TTree.cxx:2001
 TTree.cxx:2002
 TTree.cxx:2003
 TTree.cxx:2004
 TTree.cxx:2005
 TTree.cxx:2006
 TTree.cxx:2007
 TTree.cxx:2008
 TTree.cxx:2009
 TTree.cxx:2010
 TTree.cxx:2011
 TTree.cxx:2012
 TTree.cxx:2013
 TTree.cxx:2014
 TTree.cxx:2015
 TTree.cxx:2016
 TTree.cxx:2017
 TTree.cxx:2018
 TTree.cxx:2019
 TTree.cxx:2020
 TTree.cxx:2021
 TTree.cxx:2022
 TTree.cxx:2023
 TTree.cxx:2024
 TTree.cxx:2025
 TTree.cxx:2026
 TTree.cxx:2027
 TTree.cxx:2028
 TTree.cxx:2029
 TTree.cxx:2030
 TTree.cxx:2031
 TTree.cxx:2032
 TTree.cxx:2033
 TTree.cxx:2034
 TTree.cxx:2035
 TTree.cxx:2036
 TTree.cxx:2037
 TTree.cxx:2038
 TTree.cxx:2039
 TTree.cxx:2040
 TTree.cxx:2041
 TTree.cxx:2042
 TTree.cxx:2043
 TTree.cxx:2044
 TTree.cxx:2045
 TTree.cxx:2046
 TTree.cxx:2047
 TTree.cxx:2048
 TTree.cxx:2049
 TTree.cxx:2050
 TTree.cxx:2051
 TTree.cxx:2052
 TTree.cxx:2053
 TTree.cxx:2054
 TTree.cxx:2055
 TTree.cxx:2056
 TTree.cxx:2057
 TTree.cxx:2058
 TTree.cxx:2059
 TTree.cxx:2060
 TTree.cxx:2061
 TTree.cxx:2062
 TTree.cxx:2063
 TTree.cxx:2064
 TTree.cxx:2065
 TTree.cxx:2066
 TTree.cxx:2067
 TTree.cxx:2068
 TTree.cxx:2069
 TTree.cxx:2070
 TTree.cxx:2071
 TTree.cxx:2072
 TTree.cxx:2073
 TTree.cxx:2074
 TTree.cxx:2075
 TTree.cxx:2076
 TTree.cxx:2077
 TTree.cxx:2078
 TTree.cxx:2079
 TTree.cxx:2080
 TTree.cxx:2081
 TTree.cxx:2082
 TTree.cxx:2083
 TTree.cxx:2084
 TTree.cxx:2085
 TTree.cxx:2086
 TTree.cxx:2087
 TTree.cxx:2088
 TTree.cxx:2089
 TTree.cxx:2090
 TTree.cxx:2091
 TTree.cxx:2092
 TTree.cxx:2093
 TTree.cxx:2094
 TTree.cxx:2095
 TTree.cxx:2096
 TTree.cxx:2097
 TTree.cxx:2098
 TTree.cxx:2099
 TTree.cxx:2100
 TTree.cxx:2101
 TTree.cxx:2102
 TTree.cxx:2103
 TTree.cxx:2104
 TTree.cxx:2105
 TTree.cxx:2106
 TTree.cxx:2107
 TTree.cxx:2108
 TTree.cxx:2109
 TTree.cxx:2110
 TTree.cxx:2111
 TTree.cxx:2112
 TTree.cxx:2113
 TTree.cxx:2114
 TTree.cxx:2115
 TTree.cxx:2116
 TTree.cxx:2117
 TTree.cxx:2118
 TTree.cxx:2119
 TTree.cxx:2120
 TTree.cxx:2121
 TTree.cxx:2122
 TTree.cxx:2123
 TTree.cxx:2124
 TTree.cxx:2125
 TTree.cxx:2126
 TTree.cxx:2127
 TTree.cxx:2128
 TTree.cxx:2129
 TTree.cxx:2130
 TTree.cxx:2131
 TTree.cxx:2132
 TTree.cxx:2133
 TTree.cxx:2134
 TTree.cxx:2135
 TTree.cxx:2136
 TTree.cxx:2137
 TTree.cxx:2138
 TTree.cxx:2139
 TTree.cxx:2140
 TTree.cxx:2141
 TTree.cxx:2142
 TTree.cxx:2143
 TTree.cxx:2144
 TTree.cxx:2145
 TTree.cxx:2146
 TTree.cxx:2147
 TTree.cxx:2148
 TTree.cxx:2149
 TTree.cxx:2150
 TTree.cxx:2151
 TTree.cxx:2152
 TTree.cxx:2153
 TTree.cxx:2154
 TTree.cxx:2155
 TTree.cxx:2156
 TTree.cxx:2157
 TTree.cxx:2158
 TTree.cxx:2159
 TTree.cxx:2160
 TTree.cxx:2161
 TTree.cxx:2162
 TTree.cxx:2163
 TTree.cxx:2164
 TTree.cxx:2165
 TTree.cxx:2166
 TTree.cxx:2167
 TTree.cxx:2168
 TTree.cxx:2169
 TTree.cxx:2170
 TTree.cxx:2171
 TTree.cxx:2172
 TTree.cxx:2173
 TTree.cxx:2174
 TTree.cxx:2175
 TTree.cxx:2176
 TTree.cxx:2177
 TTree.cxx:2178
 TTree.cxx:2179
 TTree.cxx:2180
 TTree.cxx:2181
 TTree.cxx:2182
 TTree.cxx:2183
 TTree.cxx:2184
 TTree.cxx:2185
 TTree.cxx:2186
 TTree.cxx:2187
 TTree.cxx:2188
 TTree.cxx:2189
 TTree.cxx:2190
 TTree.cxx:2191
 TTree.cxx:2192
 TTree.cxx:2193
 TTree.cxx:2194
 TTree.cxx:2195
 TTree.cxx:2196
 TTree.cxx:2197
 TTree.cxx:2198
 TTree.cxx:2199
 TTree.cxx:2200
 TTree.cxx:2201
 TTree.cxx:2202
 TTree.cxx:2203
 TTree.cxx:2204
 TTree.cxx:2205
 TTree.cxx:2206
 TTree.cxx:2207
 TTree.cxx:2208
 TTree.cxx:2209
 TTree.cxx:2210
 TTree.cxx:2211
 TTree.cxx:2212
 TTree.cxx:2213
 TTree.cxx:2214
 TTree.cxx:2215
 TTree.cxx:2216
 TTree.cxx:2217
 TTree.cxx:2218
 TTree.cxx:2219
 TTree.cxx:2220
 TTree.cxx:2221
 TTree.cxx:2222
 TTree.cxx:2223
 TTree.cxx:2224
 TTree.cxx:2225
 TTree.cxx:2226
 TTree.cxx:2227
 TTree.cxx:2228
 TTree.cxx:2229
 TTree.cxx:2230
 TTree.cxx:2231
 TTree.cxx:2232
 TTree.cxx:2233
 TTree.cxx:2234
 TTree.cxx:2235
 TTree.cxx:2236
 TTree.cxx:2237
 TTree.cxx:2238
 TTree.cxx:2239
 TTree.cxx:2240
 TTree.cxx:2241
 TTree.cxx:2242
 TTree.cxx:2243
 TTree.cxx:2244
 TTree.cxx:2245
 TTree.cxx:2246
 TTree.cxx:2247
 TTree.cxx:2248
 TTree.cxx:2249
 TTree.cxx:2250
 TTree.cxx:2251
 TTree.cxx:2252
 TTree.cxx:2253
 TTree.cxx:2254
 TTree.cxx:2255
 TTree.cxx:2256
 TTree.cxx:2257
 TTree.cxx:2258
 TTree.cxx:2259
 TTree.cxx:2260
 TTree.cxx:2261
 TTree.cxx:2262
 TTree.cxx:2263
 TTree.cxx:2264
 TTree.cxx:2265
 TTree.cxx:2266
 TTree.cxx:2267
 TTree.cxx:2268
 TTree.cxx:2269
 TTree.cxx:2270
 TTree.cxx:2271
 TTree.cxx:2272
 TTree.cxx:2273
 TTree.cxx:2274
 TTree.cxx:2275
 TTree.cxx:2276
 TTree.cxx:2277
 TTree.cxx:2278
 TTree.cxx:2279
 TTree.cxx:2280
 TTree.cxx:2281
 TTree.cxx:2282
 TTree.cxx:2283
 TTree.cxx:2284
 TTree.cxx:2285
 TTree.cxx:2286
 TTree.cxx:2287
 TTree.cxx:2288
 TTree.cxx:2289
 TTree.cxx:2290
 TTree.cxx:2291
 TTree.cxx:2292
 TTree.cxx:2293
 TTree.cxx:2294
 TTree.cxx:2295
 TTree.cxx:2296
 TTree.cxx:2297
 TTree.cxx:2298
 TTree.cxx:2299
 TTree.cxx:2300
 TTree.cxx:2301
 TTree.cxx:2302
 TTree.cxx:2303
 TTree.cxx:2304
 TTree.cxx:2305
 TTree.cxx:2306
 TTree.cxx:2307
 TTree.cxx:2308
 TTree.cxx:2309
 TTree.cxx:2310
 TTree.cxx:2311
 TTree.cxx:2312
 TTree.cxx:2313
 TTree.cxx:2314
 TTree.cxx:2315
 TTree.cxx:2316
 TTree.cxx:2317
 TTree.cxx:2318
 TTree.cxx:2319
 TTree.cxx:2320
 TTree.cxx:2321
 TTree.cxx:2322
 TTree.cxx:2323
 TTree.cxx:2324
 TTree.cxx:2325
 TTree.cxx:2326
 TTree.cxx:2327
 TTree.cxx:2328
 TTree.cxx:2329
 TTree.cxx:2330
 TTree.cxx:2331
 TTree.cxx:2332
 TTree.cxx:2333
 TTree.cxx:2334
 TTree.cxx:2335
 TTree.cxx:2336
 TTree.cxx:2337
 TTree.cxx:2338
 TTree.cxx:2339
 TTree.cxx:2340
 TTree.cxx:2341
 TTree.cxx:2342
 TTree.cxx:2343
 TTree.cxx:2344
 TTree.cxx:2345
 TTree.cxx:2346
 TTree.cxx:2347
 TTree.cxx:2348
 TTree.cxx:2349
 TTree.cxx:2350
 TTree.cxx:2351
 TTree.cxx:2352
 TTree.cxx:2353
 TTree.cxx:2354
 TTree.cxx:2355
 TTree.cxx:2356
 TTree.cxx:2357
 TTree.cxx:2358
 TTree.cxx:2359
 TTree.cxx:2360
 TTree.cxx:2361
 TTree.cxx:2362
 TTree.cxx:2363
 TTree.cxx:2364
 TTree.cxx:2365
 TTree.cxx:2366
 TTree.cxx:2367
 TTree.cxx:2368
 TTree.cxx:2369
 TTree.cxx:2370
 TTree.cxx:2371
 TTree.cxx:2372
 TTree.cxx:2373
 TTree.cxx:2374
 TTree.cxx:2375
 TTree.cxx:2376
 TTree.cxx:2377
 TTree.cxx:2378
 TTree.cxx:2379
 TTree.cxx:2380
 TTree.cxx:2381
 TTree.cxx:2382
 TTree.cxx:2383
 TTree.cxx:2384
 TTree.cxx:2385
 TTree.cxx:2386
 TTree.cxx:2387
 TTree.cxx:2388
 TTree.cxx:2389
 TTree.cxx:2390
 TTree.cxx:2391
 TTree.cxx:2392
 TTree.cxx:2393
 TTree.cxx:2394
 TTree.cxx:2395
 TTree.cxx:2396
 TTree.cxx:2397
 TTree.cxx:2398
 TTree.cxx:2399
 TTree.cxx:2400
 TTree.cxx:2401
 TTree.cxx:2402
 TTree.cxx:2403
 TTree.cxx:2404
 TTree.cxx:2405
 TTree.cxx:2406
 TTree.cxx:2407
 TTree.cxx:2408
 TTree.cxx:2409
 TTree.cxx:2410
 TTree.cxx:2411
 TTree.cxx:2412
 TTree.cxx:2413
 TTree.cxx:2414
 TTree.cxx:2415
 TTree.cxx:2416
 TTree.cxx:2417
 TTree.cxx:2418
 TTree.cxx:2419
 TTree.cxx:2420
 TTree.cxx:2421
 TTree.cxx:2422
 TTree.cxx:2423
 TTree.cxx:2424
 TTree.cxx:2425
 TTree.cxx:2426
 TTree.cxx:2427
 TTree.cxx:2428
 TTree.cxx:2429
 TTree.cxx:2430
 TTree.cxx:2431
 TTree.cxx:2432
 TTree.cxx:2433
 TTree.cxx:2434
 TTree.cxx:2435
 TTree.cxx:2436
 TTree.cxx:2437
 TTree.cxx:2438
 TTree.cxx:2439
 TTree.cxx:2440
 TTree.cxx:2441
 TTree.cxx:2442
 TTree.cxx:2443
 TTree.cxx:2444
 TTree.cxx:2445
 TTree.cxx:2446
 TTree.cxx:2447
 TTree.cxx:2448
 TTree.cxx:2449
 TTree.cxx:2450
 TTree.cxx:2451
 TTree.cxx:2452
 TTree.cxx:2453
 TTree.cxx:2454
 TTree.cxx:2455
 TTree.cxx:2456
 TTree.cxx:2457
 TTree.cxx:2458
 TTree.cxx:2459
 TTree.cxx:2460
 TTree.cxx:2461
 TTree.cxx:2462
 TTree.cxx:2463
 TTree.cxx:2464
 TTree.cxx:2465
 TTree.cxx:2466
 TTree.cxx:2467
 TTree.cxx:2468
 TTree.cxx:2469
 TTree.cxx:2470
 TTree.cxx:2471
 TTree.cxx:2472
 TTree.cxx:2473
 TTree.cxx:2474
 TTree.cxx:2475
 TTree.cxx:2476
 TTree.cxx:2477
 TTree.cxx:2478
 TTree.cxx:2479
 TTree.cxx:2480
 TTree.cxx:2481
 TTree.cxx:2482
 TTree.cxx:2483
 TTree.cxx:2484
 TTree.cxx:2485
 TTree.cxx:2486
 TTree.cxx:2487
 TTree.cxx:2488
 TTree.cxx:2489
 TTree.cxx:2490
 TTree.cxx:2491
 TTree.cxx:2492
 TTree.cxx:2493
 TTree.cxx:2494
 TTree.cxx:2495
 TTree.cxx:2496
 TTree.cxx:2497
 TTree.cxx:2498
 TTree.cxx:2499
 TTree.cxx:2500
 TTree.cxx:2501
 TTree.cxx:2502
 TTree.cxx:2503
 TTree.cxx:2504
 TTree.cxx:2505
 TTree.cxx:2506
 TTree.cxx:2507
 TTree.cxx:2508
 TTree.cxx:2509
 TTree.cxx:2510
 TTree.cxx:2511
 TTree.cxx:2512
 TTree.cxx:2513
 TTree.cxx:2514
 TTree.cxx:2515
 TTree.cxx:2516
 TTree.cxx:2517
 TTree.cxx:2518
 TTree.cxx:2519
 TTree.cxx:2520
 TTree.cxx:2521
 TTree.cxx:2522
 TTree.cxx:2523
 TTree.cxx:2524
 TTree.cxx:2525
 TTree.cxx:2526
 TTree.cxx:2527
 TTree.cxx:2528
 TTree.cxx:2529
 TTree.cxx:2530
 TTree.cxx:2531
 TTree.cxx:2532
 TTree.cxx:2533
 TTree.cxx:2534
 TTree.cxx:2535
 TTree.cxx:2536
 TTree.cxx:2537
 TTree.cxx:2538
 TTree.cxx:2539
 TTree.cxx:2540
 TTree.cxx:2541
 TTree.cxx:2542
 TTree.cxx:2543
 TTree.cxx:2544
 TTree.cxx:2545
 TTree.cxx:2546
 TTree.cxx:2547
 TTree.cxx:2548
 TTree.cxx:2549
 TTree.cxx:2550
 TTree.cxx:2551
 TTree.cxx:2552
 TTree.cxx:2553
 TTree.cxx:2554
 TTree.cxx:2555
 TTree.cxx:2556
 TTree.cxx:2557
 TTree.cxx:2558
 TTree.cxx:2559
 TTree.cxx:2560
 TTree.cxx:2561
 TTree.cxx:2562
 TTree.cxx:2563
 TTree.cxx:2564
 TTree.cxx:2565
 TTree.cxx:2566
 TTree.cxx:2567
 TTree.cxx:2568
 TTree.cxx:2569
 TTree.cxx:2570
 TTree.cxx:2571
 TTree.cxx:2572
 TTree.cxx:2573
 TTree.cxx:2574
 TTree.cxx:2575
 TTree.cxx:2576
 TTree.cxx:2577
 TTree.cxx:2578
 TTree.cxx:2579
 TTree.cxx:2580
 TTree.cxx:2581
 TTree.cxx:2582
 TTree.cxx:2583
 TTree.cxx:2584
 TTree.cxx:2585
 TTree.cxx:2586
 TTree.cxx:2587
 TTree.cxx:2588
 TTree.cxx:2589
 TTree.cxx:2590
 TTree.cxx:2591
 TTree.cxx:2592
 TTree.cxx:2593
 TTree.cxx:2594
 TTree.cxx:2595
 TTree.cxx:2596
 TTree.cxx:2597
 TTree.cxx:2598
 TTree.cxx:2599
 TTree.cxx:2600
 TTree.cxx:2601
 TTree.cxx:2602
 TTree.cxx:2603
 TTree.cxx:2604
 TTree.cxx:2605
 TTree.cxx:2606
 TTree.cxx:2607
 TTree.cxx:2608
 TTree.cxx:2609
 TTree.cxx:2610
 TTree.cxx:2611
 TTree.cxx:2612
 TTree.cxx:2613
 TTree.cxx:2614
 TTree.cxx:2615
 TTree.cxx:2616
 TTree.cxx:2617
 TTree.cxx:2618
 TTree.cxx:2619
 TTree.cxx:2620
 TTree.cxx:2621
 TTree.cxx:2622
 TTree.cxx:2623
 TTree.cxx:2624
 TTree.cxx:2625
 TTree.cxx:2626
 TTree.cxx:2627
 TTree.cxx:2628
 TTree.cxx:2629
 TTree.cxx:2630
 TTree.cxx:2631
 TTree.cxx:2632
 TTree.cxx:2633
 TTree.cxx:2634
 TTree.cxx:2635
 TTree.cxx:2636
 TTree.cxx:2637
 TTree.cxx:2638
 TTree.cxx:2639
 TTree.cxx:2640
 TTree.cxx:2641
 TTree.cxx:2642
 TTree.cxx:2643
 TTree.cxx:2644
 TTree.cxx:2645
 TTree.cxx:2646
 TTree.cxx:2647
 TTree.cxx:2648
 TTree.cxx:2649
 TTree.cxx:2650
 TTree.cxx:2651
 TTree.cxx:2652
 TTree.cxx:2653
 TTree.cxx:2654
 TTree.cxx:2655
 TTree.cxx:2656
 TTree.cxx:2657
 TTree.cxx:2658
 TTree.cxx:2659
 TTree.cxx:2660
 TTree.cxx:2661
 TTree.cxx:2662
 TTree.cxx:2663
 TTree.cxx:2664
 TTree.cxx:2665
 TTree.cxx:2666
 TTree.cxx:2667
 TTree.cxx:2668
 TTree.cxx:2669
 TTree.cxx:2670
 TTree.cxx:2671
 TTree.cxx:2672
 TTree.cxx:2673
 TTree.cxx:2674
 TTree.cxx:2675
 TTree.cxx:2676
 TTree.cxx:2677
 TTree.cxx:2678
 TTree.cxx:2679
 TTree.cxx:2680
 TTree.cxx:2681
 TTree.cxx:2682
 TTree.cxx:2683
 TTree.cxx:2684
 TTree.cxx:2685
 TTree.cxx:2686
 TTree.cxx:2687
 TTree.cxx:2688
 TTree.cxx:2689
 TTree.cxx:2690
 TTree.cxx:2691
 TTree.cxx:2692
 TTree.cxx:2693
 TTree.cxx:2694
 TTree.cxx:2695
 TTree.cxx:2696
 TTree.cxx:2697
 TTree.cxx:2698
 TTree.cxx:2699
 TTree.cxx:2700
 TTree.cxx:2701
 TTree.cxx:2702
 TTree.cxx:2703
 TTree.cxx:2704
 TTree.cxx:2705
 TTree.cxx:2706
 TTree.cxx:2707
 TTree.cxx:2708
 TTree.cxx:2709
 TTree.cxx:2710
 TTree.cxx:2711
 TTree.cxx:2712
 TTree.cxx:2713
 TTree.cxx:2714
 TTree.cxx:2715
 TTree.cxx:2716
 TTree.cxx:2717
 TTree.cxx:2718
 TTree.cxx:2719
 TTree.cxx:2720
 TTree.cxx:2721
 TTree.cxx:2722
 TTree.cxx:2723
 TTree.cxx:2724
 TTree.cxx:2725
 TTree.cxx:2726
 TTree.cxx:2727
 TTree.cxx:2728
 TTree.cxx:2729
 TTree.cxx:2730
 TTree.cxx:2731
 TTree.cxx:2732
 TTree.cxx:2733
 TTree.cxx:2734
 TTree.cxx:2735
 TTree.cxx:2736
 TTree.cxx:2737
 TTree.cxx:2738
 TTree.cxx:2739
 TTree.cxx:2740
 TTree.cxx:2741
 TTree.cxx:2742
 TTree.cxx:2743
 TTree.cxx:2744
 TTree.cxx:2745
 TTree.cxx:2746
 TTree.cxx:2747
 TTree.cxx:2748
 TTree.cxx:2749
 TTree.cxx:2750
 TTree.cxx:2751
 TTree.cxx:2752
 TTree.cxx:2753
 TTree.cxx:2754
 TTree.cxx:2755
 TTree.cxx:2756
 TTree.cxx:2757
 TTree.cxx:2758
 TTree.cxx:2759
 TTree.cxx:2760
 TTree.cxx:2761
 TTree.cxx:2762
 TTree.cxx:2763
 TTree.cxx:2764
 TTree.cxx:2765
 TTree.cxx:2766
 TTree.cxx:2767
 TTree.cxx:2768
 TTree.cxx:2769
 TTree.cxx:2770
 TTree.cxx:2771
 TTree.cxx:2772
 TTree.cxx:2773
 TTree.cxx:2774
 TTree.cxx:2775
 TTree.cxx:2776
 TTree.cxx:2777
 TTree.cxx:2778
 TTree.cxx:2779
 TTree.cxx:2780
 TTree.cxx:2781
 TTree.cxx:2782
 TTree.cxx:2783
 TTree.cxx:2784
 TTree.cxx:2785
 TTree.cxx:2786
 TTree.cxx:2787
 TTree.cxx:2788
 TTree.cxx:2789
 TTree.cxx:2790
 TTree.cxx:2791
 TTree.cxx:2792
 TTree.cxx:2793
 TTree.cxx:2794
 TTree.cxx:2795
 TTree.cxx:2796
 TTree.cxx:2797
 TTree.cxx:2798
 TTree.cxx:2799
 TTree.cxx:2800
 TTree.cxx:2801
 TTree.cxx:2802
 TTree.cxx:2803
 TTree.cxx:2804
 TTree.cxx:2805
 TTree.cxx:2806
 TTree.cxx:2807
 TTree.cxx:2808
 TTree.cxx:2809
 TTree.cxx:2810
 TTree.cxx:2811
 TTree.cxx:2812
 TTree.cxx:2813
 TTree.cxx:2814
 TTree.cxx:2815
 TTree.cxx:2816
 TTree.cxx:2817
 TTree.cxx:2818
 TTree.cxx:2819
 TTree.cxx:2820
 TTree.cxx:2821
 TTree.cxx:2822
 TTree.cxx:2823
 TTree.cxx:2824
 TTree.cxx:2825
 TTree.cxx:2826
 TTree.cxx:2827
 TTree.cxx:2828
 TTree.cxx:2829
 TTree.cxx:2830
 TTree.cxx:2831
 TTree.cxx:2832
 TTree.cxx:2833
 TTree.cxx:2834
 TTree.cxx:2835
 TTree.cxx:2836
 TTree.cxx:2837
 TTree.cxx:2838
 TTree.cxx:2839
 TTree.cxx:2840
 TTree.cxx:2841
 TTree.cxx:2842
 TTree.cxx:2843
 TTree.cxx:2844
 TTree.cxx:2845
 TTree.cxx:2846
 TTree.cxx:2847
 TTree.cxx:2848
 TTree.cxx:2849
 TTree.cxx:2850
 TTree.cxx:2851
 TTree.cxx:2852
 TTree.cxx:2853
 TTree.cxx:2854
 TTree.cxx:2855
 TTree.cxx:2856
 TTree.cxx:2857
 TTree.cxx:2858
 TTree.cxx:2859
 TTree.cxx:2860
 TTree.cxx:2861
 TTree.cxx:2862
 TTree.cxx:2863
 TTree.cxx:2864
 TTree.cxx:2865
 TTree.cxx:2866
 TTree.cxx:2867
 TTree.cxx:2868
 TTree.cxx:2869
 TTree.cxx:2870
 TTree.cxx:2871
 TTree.cxx:2872
 TTree.cxx:2873
 TTree.cxx:2874
 TTree.cxx:2875
 TTree.cxx:2876
 TTree.cxx:2877
 TTree.cxx:2878
 TTree.cxx:2879
 TTree.cxx:2880
 TTree.cxx:2881
 TTree.cxx:2882
 TTree.cxx:2883
 TTree.cxx:2884
 TTree.cxx:2885
 TTree.cxx:2886
 TTree.cxx:2887
 TTree.cxx:2888
 TTree.cxx:2889
 TTree.cxx:2890
 TTree.cxx:2891
 TTree.cxx:2892
 TTree.cxx:2893
 TTree.cxx:2894
 TTree.cxx:2895
 TTree.cxx:2896
 TTree.cxx:2897
 TTree.cxx:2898
 TTree.cxx:2899
 TTree.cxx:2900
 TTree.cxx:2901
 TTree.cxx:2902
 TTree.cxx:2903
 TTree.cxx:2904
 TTree.cxx:2905
 TTree.cxx:2906
 TTree.cxx:2907
 TTree.cxx:2908
 TTree.cxx:2909
 TTree.cxx:2910
 TTree.cxx:2911
 TTree.cxx:2912
 TTree.cxx:2913
 TTree.cxx:2914
 TTree.cxx:2915
 TTree.cxx:2916
 TTree.cxx:2917
 TTree.cxx:2918
 TTree.cxx:2919
 TTree.cxx:2920
 TTree.cxx:2921
 TTree.cxx:2922
 TTree.cxx:2923
 TTree.cxx:2924
 TTree.cxx:2925
 TTree.cxx:2926
 TTree.cxx:2927
 TTree.cxx:2928
 TTree.cxx:2929
 TTree.cxx:2930
 TTree.cxx:2931
 TTree.cxx:2932
 TTree.cxx:2933
 TTree.cxx:2934
 TTree.cxx:2935
 TTree.cxx:2936
 TTree.cxx:2937
 TTree.cxx:2938
 TTree.cxx:2939
 TTree.cxx:2940
 TTree.cxx:2941
 TTree.cxx:2942
 TTree.cxx:2943
 TTree.cxx:2944
 TTree.cxx:2945
 TTree.cxx:2946
 TTree.cxx:2947
 TTree.cxx:2948
 TTree.cxx:2949
 TTree.cxx:2950
 TTree.cxx:2951
 TTree.cxx:2952
 TTree.cxx:2953
 TTree.cxx:2954
 TTree.cxx:2955
 TTree.cxx:2956
 TTree.cxx:2957
 TTree.cxx:2958
 TTree.cxx:2959
 TTree.cxx:2960
 TTree.cxx:2961
 TTree.cxx:2962
 TTree.cxx:2963
 TTree.cxx:2964
 TTree.cxx:2965
 TTree.cxx:2966
 TTree.cxx:2967
 TTree.cxx:2968
 TTree.cxx:2969
 TTree.cxx:2970
 TTree.cxx:2971
 TTree.cxx:2972
 TTree.cxx:2973
 TTree.cxx:2974
 TTree.cxx:2975
 TTree.cxx:2976
 TTree.cxx:2977
 TTree.cxx:2978
 TTree.cxx:2979
 TTree.cxx:2980
 TTree.cxx:2981
 TTree.cxx:2982
 TTree.cxx:2983
 TTree.cxx:2984
 TTree.cxx:2985
 TTree.cxx:2986
 TTree.cxx:2987
 TTree.cxx:2988
 TTree.cxx:2989
 TTree.cxx:2990
 TTree.cxx:2991
 TTree.cxx:2992
 TTree.cxx:2993
 TTree.cxx:2994
 TTree.cxx:2995
 TTree.cxx:2996
 TTree.cxx:2997
 TTree.cxx:2998
 TTree.cxx:2999
 TTree.cxx:3000
 TTree.cxx:3001
 TTree.cxx:3002
 TTree.cxx:3003
 TTree.cxx:3004
 TTree.cxx:3005
 TTree.cxx:3006
 TTree.cxx:3007
 TTree.cxx:3008
 TTree.cxx:3009
 TTree.cxx:3010
 TTree.cxx:3011
 TTree.cxx:3012
 TTree.cxx:3013
 TTree.cxx:3014
 TTree.cxx:3015
 TTree.cxx:3016
 TTree.cxx:3017
 TTree.cxx:3018
 TTree.cxx:3019
 TTree.cxx:3020
 TTree.cxx:3021
 TTree.cxx:3022
 TTree.cxx:3023
 TTree.cxx:3024
 TTree.cxx:3025
 TTree.cxx:3026
 TTree.cxx:3027
 TTree.cxx:3028
 TTree.cxx:3029
 TTree.cxx:3030
 TTree.cxx:3031
 TTree.cxx:3032
 TTree.cxx:3033
 TTree.cxx:3034
 TTree.cxx:3035
 TTree.cxx:3036
 TTree.cxx:3037
 TTree.cxx:3038
 TTree.cxx:3039
 TTree.cxx:3040
 TTree.cxx:3041
 TTree.cxx:3042
 TTree.cxx:3043
 TTree.cxx:3044
 TTree.cxx:3045
 TTree.cxx:3046
 TTree.cxx:3047
 TTree.cxx:3048
 TTree.cxx:3049
 TTree.cxx:3050
 TTree.cxx:3051
 TTree.cxx:3052
 TTree.cxx:3053
 TTree.cxx:3054
 TTree.cxx:3055
 TTree.cxx:3056
 TTree.cxx:3057
 TTree.cxx:3058
 TTree.cxx:3059
 TTree.cxx:3060
 TTree.cxx:3061
 TTree.cxx:3062
 TTree.cxx:3063
 TTree.cxx:3064
 TTree.cxx:3065
 TTree.cxx:3066
 TTree.cxx:3067
 TTree.cxx:3068
 TTree.cxx:3069
 TTree.cxx:3070
 TTree.cxx:3071
 TTree.cxx:3072
 TTree.cxx:3073
 TTree.cxx:3074
 TTree.cxx:3075
 TTree.cxx:3076
 TTree.cxx:3077
 TTree.cxx:3078
 TTree.cxx:3079
 TTree.cxx:3080
 TTree.cxx:3081
 TTree.cxx:3082
 TTree.cxx:3083
 TTree.cxx:3084
 TTree.cxx:3085
 TTree.cxx:3086
 TTree.cxx:3087
 TTree.cxx:3088
 TTree.cxx:3089
 TTree.cxx:3090
 TTree.cxx:3091
 TTree.cxx:3092
 TTree.cxx:3093
 TTree.cxx:3094
 TTree.cxx:3095
 TTree.cxx:3096
 TTree.cxx:3097
 TTree.cxx:3098
 TTree.cxx:3099
 TTree.cxx:3100
 TTree.cxx:3101
 TTree.cxx:3102
 TTree.cxx:3103
 TTree.cxx:3104
 TTree.cxx:3105
 TTree.cxx:3106
 TTree.cxx:3107
 TTree.cxx:3108
 TTree.cxx:3109
 TTree.cxx:3110
 TTree.cxx:3111
 TTree.cxx:3112
 TTree.cxx:3113
 TTree.cxx:3114
 TTree.cxx:3115
 TTree.cxx:3116
 TTree.cxx:3117
 TTree.cxx:3118
 TTree.cxx:3119
 TTree.cxx:3120
 TTree.cxx:3121
 TTree.cxx:3122
 TTree.cxx:3123
 TTree.cxx:3124
 TTree.cxx:3125
 TTree.cxx:3126
 TTree.cxx:3127
 TTree.cxx:3128
 TTree.cxx:3129
 TTree.cxx:3130
 TTree.cxx:3131
 TTree.cxx:3132
 TTree.cxx:3133
 TTree.cxx:3134
 TTree.cxx:3135
 TTree.cxx:3136
 TTree.cxx:3137
 TTree.cxx:3138
 TTree.cxx:3139
 TTree.cxx:3140
 TTree.cxx:3141
 TTree.cxx:3142
 TTree.cxx:3143
 TTree.cxx:3144
 TTree.cxx:3145
 TTree.cxx:3146
 TTree.cxx:3147
 TTree.cxx:3148
 TTree.cxx:3149
 TTree.cxx:3150
 TTree.cxx:3151
 TTree.cxx:3152
 TTree.cxx:3153
 TTree.cxx:3154
 TTree.cxx:3155
 TTree.cxx:3156
 TTree.cxx:3157
 TTree.cxx:3158
 TTree.cxx:3159
 TTree.cxx:3160
 TTree.cxx:3161
 TTree.cxx:3162
 TTree.cxx:3163
 TTree.cxx:3164
 TTree.cxx:3165
 TTree.cxx:3166
 TTree.cxx:3167
 TTree.cxx:3168
 TTree.cxx:3169
 TTree.cxx:3170
 TTree.cxx:3171
 TTree.cxx:3172
 TTree.cxx:3173
 TTree.cxx:3174
 TTree.cxx:3175
 TTree.cxx:3176
 TTree.cxx:3177
 TTree.cxx:3178
 TTree.cxx:3179
 TTree.cxx:3180
 TTree.cxx:3181
 TTree.cxx:3182
 TTree.cxx:3183
 TTree.cxx:3184
 TTree.cxx:3185
 TTree.cxx:3186
 TTree.cxx:3187
 TTree.cxx:3188
 TTree.cxx:3189
 TTree.cxx:3190
 TTree.cxx:3191
 TTree.cxx:3192
 TTree.cxx:3193
 TTree.cxx:3194
 TTree.cxx:3195
 TTree.cxx:3196
 TTree.cxx:3197
 TTree.cxx:3198
 TTree.cxx:3199
 TTree.cxx:3200
 TTree.cxx:3201
 TTree.cxx:3202
 TTree.cxx:3203
 TTree.cxx:3204
 TTree.cxx:3205
 TTree.cxx:3206
 TTree.cxx:3207
 TTree.cxx:3208
 TTree.cxx:3209
 TTree.cxx:3210
 TTree.cxx:3211
 TTree.cxx:3212
 TTree.cxx:3213
 TTree.cxx:3214
 TTree.cxx:3215
 TTree.cxx:3216
 TTree.cxx:3217
 TTree.cxx:3218
 TTree.cxx:3219
 TTree.cxx:3220
 TTree.cxx:3221
 TTree.cxx:3222
 TTree.cxx:3223
 TTree.cxx:3224
 TTree.cxx:3225
 TTree.cxx:3226
 TTree.cxx:3227
 TTree.cxx:3228
 TTree.cxx:3229
 TTree.cxx:3230
 TTree.cxx:3231
 TTree.cxx:3232
 TTree.cxx:3233
 TTree.cxx:3234
 TTree.cxx:3235
 TTree.cxx:3236
 TTree.cxx:3237
 TTree.cxx:3238
 TTree.cxx:3239
 TTree.cxx:3240
 TTree.cxx:3241
 TTree.cxx:3242
 TTree.cxx:3243
 TTree.cxx:3244
 TTree.cxx:3245
 TTree.cxx:3246
 TTree.cxx:3247
 TTree.cxx:3248
 TTree.cxx:3249
 TTree.cxx:3250
 TTree.cxx:3251
 TTree.cxx:3252
 TTree.cxx:3253
 TTree.cxx:3254
 TTree.cxx:3255
 TTree.cxx:3256
 TTree.cxx:3257
 TTree.cxx:3258
 TTree.cxx:3259
 TTree.cxx:3260
 TTree.cxx:3261
 TTree.cxx:3262
 TTree.cxx:3263
 TTree.cxx:3264
 TTree.cxx:3265
 TTree.cxx:3266
 TTree.cxx:3267
 TTree.cxx:3268
 TTree.cxx:3269
 TTree.cxx:3270
 TTree.cxx:3271
 TTree.cxx:3272
 TTree.cxx:3273
 TTree.cxx:3274
 TTree.cxx:3275
 TTree.cxx:3276
 TTree.cxx:3277
 TTree.cxx:3278
 TTree.cxx:3279
 TTree.cxx:3280
 TTree.cxx:3281
 TTree.cxx:3282
 TTree.cxx:3283
 TTree.cxx:3284
 TTree.cxx:3285
 TTree.cxx:3286
 TTree.cxx:3287
 TTree.cxx:3288
 TTree.cxx:3289
 TTree.cxx:3290
 TTree.cxx:3291
 TTree.cxx:3292
 TTree.cxx:3293
 TTree.cxx:3294
 TTree.cxx:3295
 TTree.cxx:3296
 TTree.cxx:3297
 TTree.cxx:3298
 TTree.cxx:3299
 TTree.cxx:3300
 TTree.cxx:3301
 TTree.cxx:3302
 TTree.cxx:3303
 TTree.cxx:3304
 TTree.cxx:3305
 TTree.cxx:3306
 TTree.cxx:3307
 TTree.cxx:3308
 TTree.cxx:3309
 TTree.cxx:3310
 TTree.cxx:3311
 TTree.cxx:3312
 TTree.cxx:3313
 TTree.cxx:3314
 TTree.cxx:3315
 TTree.cxx:3316
 TTree.cxx:3317
 TTree.cxx:3318
 TTree.cxx:3319
 TTree.cxx:3320
 TTree.cxx:3321
 TTree.cxx:3322
 TTree.cxx:3323
 TTree.cxx:3324
 TTree.cxx:3325
 TTree.cxx:3326
 TTree.cxx:3327
 TTree.cxx:3328
 TTree.cxx:3329
 TTree.cxx:3330
 TTree.cxx:3331
 TTree.cxx:3332
 TTree.cxx:3333
 TTree.cxx:3334
 TTree.cxx:3335
 TTree.cxx:3336
 TTree.cxx:3337
 TTree.cxx:3338
 TTree.cxx:3339
 TTree.cxx:3340
 TTree.cxx:3341
 TTree.cxx:3342
 TTree.cxx:3343
 TTree.cxx:3344
 TTree.cxx:3345
 TTree.cxx:3346
 TTree.cxx:3347
 TTree.cxx:3348
 TTree.cxx:3349
 TTree.cxx:3350
 TTree.cxx:3351
 TTree.cxx:3352
 TTree.cxx:3353
 TTree.cxx:3354
 TTree.cxx:3355
 TTree.cxx:3356
 TTree.cxx:3357
 TTree.cxx:3358
 TTree.cxx:3359
 TTree.cxx:3360
 TTree.cxx:3361
 TTree.cxx:3362
 TTree.cxx:3363
 TTree.cxx:3364
 TTree.cxx:3365
 TTree.cxx:3366
 TTree.cxx:3367
 TTree.cxx:3368
 TTree.cxx:3369
 TTree.cxx:3370
 TTree.cxx:3371
 TTree.cxx:3372
 TTree.cxx:3373
 TTree.cxx:3374
 TTree.cxx:3375
 TTree.cxx:3376
 TTree.cxx:3377
 TTree.cxx:3378
 TTree.cxx:3379
 TTree.cxx:3380
 TTree.cxx:3381
 TTree.cxx:3382
 TTree.cxx:3383
 TTree.cxx:3384
 TTree.cxx:3385
 TTree.cxx:3386
 TTree.cxx:3387
 TTree.cxx:3388
 TTree.cxx:3389
 TTree.cxx:3390
 TTree.cxx:3391
 TTree.cxx:3392
 TTree.cxx:3393
 TTree.cxx:3394
 TTree.cxx:3395
 TTree.cxx:3396
 TTree.cxx:3397
 TTree.cxx:3398
 TTree.cxx:3399
 TTree.cxx:3400
 TTree.cxx:3401
 TTree.cxx:3402
 TTree.cxx:3403
 TTree.cxx:3404
 TTree.cxx:3405
 TTree.cxx:3406
 TTree.cxx:3407
 TTree.cxx:3408
 TTree.cxx:3409
 TTree.cxx:3410
 TTree.cxx:3411
 TTree.cxx:3412
 TTree.cxx:3413
 TTree.cxx:3414
 TTree.cxx:3415
 TTree.cxx:3416
 TTree.cxx:3417
 TTree.cxx:3418
 TTree.cxx:3419
 TTree.cxx:3420
 TTree.cxx:3421
 TTree.cxx:3422
 TTree.cxx:3423
 TTree.cxx:3424
 TTree.cxx:3425
 TTree.cxx:3426
 TTree.cxx:3427
 TTree.cxx:3428
 TTree.cxx:3429
 TTree.cxx:3430
 TTree.cxx:3431
 TTree.cxx:3432
 TTree.cxx:3433
 TTree.cxx:3434
 TTree.cxx:3435
 TTree.cxx:3436
 TTree.cxx:3437
 TTree.cxx:3438
 TTree.cxx:3439
 TTree.cxx:3440
 TTree.cxx:3441
 TTree.cxx:3442
 TTree.cxx:3443
 TTree.cxx:3444
 TTree.cxx:3445
 TTree.cxx:3446
 TTree.cxx:3447
 TTree.cxx:3448
 TTree.cxx:3449
 TTree.cxx:3450
 TTree.cxx:3451
 TTree.cxx:3452
 TTree.cxx:3453
 TTree.cxx:3454
 TTree.cxx:3455
 TTree.cxx:3456
 TTree.cxx:3457
 TTree.cxx:3458
 TTree.cxx:3459
 TTree.cxx:3460
 TTree.cxx:3461
 TTree.cxx:3462
 TTree.cxx:3463
 TTree.cxx:3464
 TTree.cxx:3465
 TTree.cxx:3466
 TTree.cxx:3467
 TTree.cxx:3468
 TTree.cxx:3469
 TTree.cxx:3470
 TTree.cxx:3471
 TTree.cxx:3472
 TTree.cxx:3473
 TTree.cxx:3474
 TTree.cxx:3475
 TTree.cxx:3476
 TTree.cxx:3477
 TTree.cxx:3478
 TTree.cxx:3479
 TTree.cxx:3480
 TTree.cxx:3481
 TTree.cxx:3482
 TTree.cxx:3483
 TTree.cxx:3484
 TTree.cxx:3485
 TTree.cxx:3486
 TTree.cxx:3487
 TTree.cxx:3488
 TTree.cxx:3489
 TTree.cxx:3490
 TTree.cxx:3491
 TTree.cxx:3492
 TTree.cxx:3493
 TTree.cxx:3494
 TTree.cxx:3495
 TTree.cxx:3496
 TTree.cxx:3497
 TTree.cxx:3498
 TTree.cxx:3499
 TTree.cxx:3500
 TTree.cxx:3501
 TTree.cxx:3502
 TTree.cxx:3503
 TTree.cxx:3504
 TTree.cxx:3505
 TTree.cxx:3506
 TTree.cxx:3507
 TTree.cxx:3508
 TTree.cxx:3509
 TTree.cxx:3510
 TTree.cxx:3511
 TTree.cxx:3512
 TTree.cxx:3513
 TTree.cxx:3514
 TTree.cxx:3515
 TTree.cxx:3516
 TTree.cxx:3517
 TTree.cxx:3518
 TTree.cxx:3519
 TTree.cxx:3520
 TTree.cxx:3521
 TTree.cxx:3522
 TTree.cxx:3523
 TTree.cxx:3524
 TTree.cxx:3525
 TTree.cxx:3526
 TTree.cxx:3527
 TTree.cxx:3528
 TTree.cxx:3529
 TTree.cxx:3530
 TTree.cxx:3531
 TTree.cxx:3532
 TTree.cxx:3533
 TTree.cxx:3534
 TTree.cxx:3535
 TTree.cxx:3536
 TTree.cxx:3537
 TTree.cxx:3538
 TTree.cxx:3539
 TTree.cxx:3540
 TTree.cxx:3541
 TTree.cxx:3542
 TTree.cxx:3543
 TTree.cxx:3544
 TTree.cxx:3545
 TTree.cxx:3546
 TTree.cxx:3547
 TTree.cxx:3548
 TTree.cxx:3549
 TTree.cxx:3550
 TTree.cxx:3551
 TTree.cxx:3552
 TTree.cxx:3553
 TTree.cxx:3554
 TTree.cxx:3555
 TTree.cxx:3556
 TTree.cxx:3557
 TTree.cxx:3558
 TTree.cxx:3559
 TTree.cxx:3560
 TTree.cxx:3561
 TTree.cxx:3562
 TTree.cxx:3563
 TTree.cxx:3564
 TTree.cxx:3565
 TTree.cxx:3566
 TTree.cxx:3567
 TTree.cxx:3568
 TTree.cxx:3569
 TTree.cxx:3570
 TTree.cxx:3571
 TTree.cxx:3572
 TTree.cxx:3573
 TTree.cxx:3574
 TTree.cxx:3575
 TTree.cxx:3576
 TTree.cxx:3577
 TTree.cxx:3578
 TTree.cxx:3579
 TTree.cxx:3580
 TTree.cxx:3581
 TTree.cxx:3582
 TTree.cxx:3583
 TTree.cxx:3584
 TTree.cxx:3585
 TTree.cxx:3586
 TTree.cxx:3587
 TTree.cxx:3588
 TTree.cxx:3589
 TTree.cxx:3590
 TTree.cxx:3591
 TTree.cxx:3592
 TTree.cxx:3593
 TTree.cxx:3594
 TTree.cxx:3595
 TTree.cxx:3596
 TTree.cxx:3597
 TTree.cxx:3598
 TTree.cxx:3599
 TTree.cxx:3600
 TTree.cxx:3601
 TTree.cxx:3602
 TTree.cxx:3603
 TTree.cxx:3604
 TTree.cxx:3605
 TTree.cxx:3606
 TTree.cxx:3607
 TTree.cxx:3608
 TTree.cxx:3609
 TTree.cxx:3610
 TTree.cxx:3611
 TTree.cxx:3612
 TTree.cxx:3613
 TTree.cxx:3614
 TTree.cxx:3615
 TTree.cxx:3616
 TTree.cxx:3617
 TTree.cxx:3618
 TTree.cxx:3619
 TTree.cxx:3620
 TTree.cxx:3621
 TTree.cxx:3622
 TTree.cxx:3623
 TTree.cxx:3624
 TTree.cxx:3625
 TTree.cxx:3626
 TTree.cxx:3627
 TTree.cxx:3628
 TTree.cxx:3629
 TTree.cxx:3630
 TTree.cxx:3631
 TTree.cxx:3632
 TTree.cxx:3633
 TTree.cxx:3634
 TTree.cxx:3635
 TTree.cxx:3636
 TTree.cxx:3637
 TTree.cxx:3638
 TTree.cxx:3639
 TTree.cxx:3640
 TTree.cxx:3641
 TTree.cxx:3642
 TTree.cxx:3643
 TTree.cxx:3644
 TTree.cxx:3645
 TTree.cxx:3646
 TTree.cxx:3647
 TTree.cxx:3648
 TTree.cxx:3649
 TTree.cxx:3650
 TTree.cxx:3651
 TTree.cxx:3652
 TTree.cxx:3653
 TTree.cxx:3654
 TTree.cxx:3655
 TTree.cxx:3656
 TTree.cxx:3657
 TTree.cxx:3658
 TTree.cxx:3659
 TTree.cxx:3660
 TTree.cxx:3661
 TTree.cxx:3662
 TTree.cxx:3663
 TTree.cxx:3664
 TTree.cxx:3665
 TTree.cxx:3666
 TTree.cxx:3667
 TTree.cxx:3668
 TTree.cxx:3669
 TTree.cxx:3670
 TTree.cxx:3671
 TTree.cxx:3672
 TTree.cxx:3673
 TTree.cxx:3674
 TTree.cxx:3675
 TTree.cxx:3676
 TTree.cxx:3677
 TTree.cxx:3678
 TTree.cxx:3679
 TTree.cxx:3680
 TTree.cxx:3681
 TTree.cxx:3682
 TTree.cxx:3683
 TTree.cxx:3684
 TTree.cxx:3685
 TTree.cxx:3686
 TTree.cxx:3687
 TTree.cxx:3688
 TTree.cxx:3689
 TTree.cxx:3690
 TTree.cxx:3691
 TTree.cxx:3692
 TTree.cxx:3693
 TTree.cxx:3694
 TTree.cxx:3695
 TTree.cxx:3696
 TTree.cxx:3697
 TTree.cxx:3698
 TTree.cxx:3699
 TTree.cxx:3700
 TTree.cxx:3701
 TTree.cxx:3702
 TTree.cxx:3703
 TTree.cxx:3704
 TTree.cxx:3705
 TTree.cxx:3706
 TTree.cxx:3707
 TTree.cxx:3708
 TTree.cxx:3709
 TTree.cxx:3710
 TTree.cxx:3711
 TTree.cxx:3712
 TTree.cxx:3713
 TTree.cxx:3714
 TTree.cxx:3715
 TTree.cxx:3716
 TTree.cxx:3717
 TTree.cxx:3718
 TTree.cxx:3719
 TTree.cxx:3720
 TTree.cxx:3721
 TTree.cxx:3722
 TTree.cxx:3723
 TTree.cxx:3724
 TTree.cxx:3725
 TTree.cxx:3726
 TTree.cxx:3727
 TTree.cxx:3728
 TTree.cxx:3729
 TTree.cxx:3730
 TTree.cxx:3731
 TTree.cxx:3732
 TTree.cxx:3733
 TTree.cxx:3734
 TTree.cxx:3735
 TTree.cxx:3736
 TTree.cxx:3737
 TTree.cxx:3738
 TTree.cxx:3739
 TTree.cxx:3740
 TTree.cxx:3741
 TTree.cxx:3742
 TTree.cxx:3743
 TTree.cxx:3744
 TTree.cxx:3745
 TTree.cxx:3746
 TTree.cxx:3747
 TTree.cxx:3748
 TTree.cxx:3749
 TTree.cxx:3750
 TTree.cxx:3751
 TTree.cxx:3752
 TTree.cxx:3753
 TTree.cxx:3754
 TTree.cxx:3755
 TTree.cxx:3756
 TTree.cxx:3757
 TTree.cxx:3758
 TTree.cxx:3759
 TTree.cxx:3760
 TTree.cxx:3761
 TTree.cxx:3762
 TTree.cxx:3763
 TTree.cxx:3764
 TTree.cxx:3765
 TTree.cxx:3766
 TTree.cxx:3767
 TTree.cxx:3768
 TTree.cxx:3769
 TTree.cxx:3770
 TTree.cxx:3771
 TTree.cxx:3772
 TTree.cxx:3773
 TTree.cxx:3774
 TTree.cxx:3775
 TTree.cxx:3776
 TTree.cxx:3777
 TTree.cxx:3778
 TTree.cxx:3779
 TTree.cxx:3780
 TTree.cxx:3781
 TTree.cxx:3782
 TTree.cxx:3783
 TTree.cxx:3784
 TTree.cxx:3785
 TTree.cxx:3786
 TTree.cxx:3787
 TTree.cxx:3788
 TTree.cxx:3789
 TTree.cxx:3790
 TTree.cxx:3791
 TTree.cxx:3792
 TTree.cxx:3793
 TTree.cxx:3794
 TTree.cxx:3795
 TTree.cxx:3796
 TTree.cxx:3797
 TTree.cxx:3798
 TTree.cxx:3799
 TTree.cxx:3800
 TTree.cxx:3801
 TTree.cxx:3802
 TTree.cxx:3803
 TTree.cxx:3804
 TTree.cxx:3805
 TTree.cxx:3806
 TTree.cxx:3807
 TTree.cxx:3808
 TTree.cxx:3809
 TTree.cxx:3810
 TTree.cxx:3811
 TTree.cxx:3812
 TTree.cxx:3813
 TTree.cxx:3814
 TTree.cxx:3815
 TTree.cxx:3816
 TTree.cxx:3817
 TTree.cxx:3818
 TTree.cxx:3819
 TTree.cxx:3820
 TTree.cxx:3821
 TTree.cxx:3822
 TTree.cxx:3823
 TTree.cxx:3824
 TTree.cxx:3825
 TTree.cxx:3826
 TTree.cxx:3827
 TTree.cxx:3828
 TTree.cxx:3829
 TTree.cxx:3830
 TTree.cxx:3831
 TTree.cxx:3832
 TTree.cxx:3833
 TTree.cxx:3834
 TTree.cxx:3835
 TTree.cxx:3836
 TTree.cxx:3837
 TTree.cxx:3838
 TTree.cxx:3839
 TTree.cxx:3840
 TTree.cxx:3841
 TTree.cxx:3842
 TTree.cxx:3843
 TTree.cxx:3844
 TTree.cxx:3845
 TTree.cxx:3846
 TTree.cxx:3847
 TTree.cxx:3848
 TTree.cxx:3849
 TTree.cxx:3850
 TTree.cxx:3851
 TTree.cxx:3852
 TTree.cxx:3853
 TTree.cxx:3854
 TTree.cxx:3855
 TTree.cxx:3856
 TTree.cxx:3857
 TTree.cxx:3858
 TTree.cxx:3859
 TTree.cxx:3860
 TTree.cxx:3861
 TTree.cxx:3862
 TTree.cxx:3863
 TTree.cxx:3864
 TTree.cxx:3865
 TTree.cxx:3866
 TTree.cxx:3867
 TTree.cxx:3868
 TTree.cxx:3869
 TTree.cxx:3870
 TTree.cxx:3871
 TTree.cxx:3872
 TTree.cxx:3873
 TTree.cxx:3874
 TTree.cxx:3875
 TTree.cxx:3876
 TTree.cxx:3877
 TTree.cxx:3878
 TTree.cxx:3879
 TTree.cxx:3880
 TTree.cxx:3881
 TTree.cxx:3882
 TTree.cxx:3883
 TTree.cxx:3884
 TTree.cxx:3885
 TTree.cxx:3886
 TTree.cxx:3887
 TTree.cxx:3888
 TTree.cxx:3889
 TTree.cxx:3890
 TTree.cxx:3891
 TTree.cxx:3892
 TTree.cxx:3893
 TTree.cxx:3894
 TTree.cxx:3895
 TTree.cxx:3896
 TTree.cxx:3897
 TTree.cxx:3898
 TTree.cxx:3899
 TTree.cxx:3900
 TTree.cxx:3901
 TTree.cxx:3902
 TTree.cxx:3903
 TTree.cxx:3904
 TTree.cxx:3905
 TTree.cxx:3906
 TTree.cxx:3907
 TTree.cxx:3908
 TTree.cxx:3909
 TTree.cxx:3910
 TTree.cxx:3911
 TTree.cxx:3912
 TTree.cxx:3913
 TTree.cxx:3914
 TTree.cxx:3915
 TTree.cxx:3916
 TTree.cxx:3917
 TTree.cxx:3918
 TTree.cxx:3919
 TTree.cxx:3920
 TTree.cxx:3921
 TTree.cxx:3922
 TTree.cxx:3923
 TTree.cxx:3924
 TTree.cxx:3925
 TTree.cxx:3926
 TTree.cxx:3927
 TTree.cxx:3928
 TTree.cxx:3929
 TTree.cxx:3930
 TTree.cxx:3931
 TTree.cxx:3932
 TTree.cxx:3933
 TTree.cxx:3934
 TTree.cxx:3935
 TTree.cxx:3936
 TTree.cxx:3937
 TTree.cxx:3938
 TTree.cxx:3939
 TTree.cxx:3940
 TTree.cxx:3941
 TTree.cxx:3942
 TTree.cxx:3943
 TTree.cxx:3944
 TTree.cxx:3945
 TTree.cxx:3946
 TTree.cxx:3947
 TTree.cxx:3948
 TTree.cxx:3949
 TTree.cxx:3950
 TTree.cxx:3951
 TTree.cxx:3952
 TTree.cxx:3953
 TTree.cxx:3954
 TTree.cxx:3955
 TTree.cxx:3956
 TTree.cxx:3957
 TTree.cxx:3958
 TTree.cxx:3959
 TTree.cxx:3960
 TTree.cxx:3961
 TTree.cxx:3962
 TTree.cxx:3963
 TTree.cxx:3964
 TTree.cxx:3965
 TTree.cxx:3966
 TTree.cxx:3967
 TTree.cxx:3968
 TTree.cxx:3969
 TTree.cxx:3970
 TTree.cxx:3971
 TTree.cxx:3972
 TTree.cxx:3973
 TTree.cxx:3974
 TTree.cxx:3975
 TTree.cxx:3976
 TTree.cxx:3977
 TTree.cxx:3978
 TTree.cxx:3979
 TTree.cxx:3980
 TTree.cxx:3981
 TTree.cxx:3982
 TTree.cxx:3983
 TTree.cxx:3984
 TTree.cxx:3985
 TTree.cxx:3986
 TTree.cxx:3987
 TTree.cxx:3988
 TTree.cxx:3989
 TTree.cxx:3990
 TTree.cxx:3991
 TTree.cxx:3992
 TTree.cxx:3993
 TTree.cxx:3994
 TTree.cxx:3995
 TTree.cxx:3996
 TTree.cxx:3997
 TTree.cxx:3998
 TTree.cxx:3999
 TTree.cxx:4000
 TTree.cxx:4001
 TTree.cxx:4002
 TTree.cxx:4003
 TTree.cxx:4004
 TTree.cxx:4005
 TTree.cxx:4006
 TTree.cxx:4007
 TTree.cxx:4008
 TTree.cxx:4009
 TTree.cxx:4010
 TTree.cxx:4011
 TTree.cxx:4012
 TTree.cxx:4013
 TTree.cxx:4014
 TTree.cxx:4015
 TTree.cxx:4016
 TTree.cxx:4017
 TTree.cxx:4018
 TTree.cxx:4019
 TTree.cxx:4020
 TTree.cxx:4021
 TTree.cxx:4022
 TTree.cxx:4023
 TTree.cxx:4024
 TTree.cxx:4025
 TTree.cxx:4026
 TTree.cxx:4027
 TTree.cxx:4028
 TTree.cxx:4029
 TTree.cxx:4030
 TTree.cxx:4031
 TTree.cxx:4032
 TTree.cxx:4033
 TTree.cxx:4034
 TTree.cxx:4035
 TTree.cxx:4036
 TTree.cxx:4037
 TTree.cxx:4038
 TTree.cxx:4039
 TTree.cxx:4040
 TTree.cxx:4041
 TTree.cxx:4042
 TTree.cxx:4043
 TTree.cxx:4044
 TTree.cxx:4045
 TTree.cxx:4046
 TTree.cxx:4047
 TTree.cxx:4048
 TTree.cxx:4049
 TTree.cxx:4050
 TTree.cxx:4051
 TTree.cxx:4052
 TTree.cxx:4053
 TTree.cxx:4054
 TTree.cxx:4055
 TTree.cxx:4056
 TTree.cxx:4057
 TTree.cxx:4058
 TTree.cxx:4059
 TTree.cxx:4060
 TTree.cxx:4061
 TTree.cxx:4062
 TTree.cxx:4063
 TTree.cxx:4064
 TTree.cxx:4065
 TTree.cxx:4066
 TTree.cxx:4067
 TTree.cxx:4068
 TTree.cxx:4069
 TTree.cxx:4070
 TTree.cxx:4071
 TTree.cxx:4072
 TTree.cxx:4073
 TTree.cxx:4074
 TTree.cxx:4075
 TTree.cxx:4076
 TTree.cxx:4077
 TTree.cxx:4078
 TTree.cxx:4079
 TTree.cxx:4080
 TTree.cxx:4081
 TTree.cxx:4082
 TTree.cxx:4083
 TTree.cxx:4084
 TTree.cxx:4085
 TTree.cxx:4086
 TTree.cxx:4087
 TTree.cxx:4088
 TTree.cxx:4089
 TTree.cxx:4090
 TTree.cxx:4091
 TTree.cxx:4092
 TTree.cxx:4093
 TTree.cxx:4094
 TTree.cxx:4095
 TTree.cxx:4096
 TTree.cxx:4097
 TTree.cxx:4098
 TTree.cxx:4099
 TTree.cxx:4100
 TTree.cxx:4101
 TTree.cxx:4102
 TTree.cxx:4103
 TTree.cxx:4104
 TTree.cxx:4105
 TTree.cxx:4106
 TTree.cxx:4107
 TTree.cxx:4108
 TTree.cxx:4109
 TTree.cxx:4110
 TTree.cxx:4111
 TTree.cxx:4112
 TTree.cxx:4113
 TTree.cxx:4114
 TTree.cxx:4115
 TTree.cxx:4116
 TTree.cxx:4117
 TTree.cxx:4118
 TTree.cxx:4119
 TTree.cxx:4120
 TTree.cxx:4121
 TTree.cxx:4122
 TTree.cxx:4123
 TTree.cxx:4124
 TTree.cxx:4125
 TTree.cxx:4126
 TTree.cxx:4127
 TTree.cxx:4128
 TTree.cxx:4129
 TTree.cxx:4130
 TTree.cxx:4131
 TTree.cxx:4132
 TTree.cxx:4133
 TTree.cxx:4134
 TTree.cxx:4135
 TTree.cxx:4136
 TTree.cxx:4137
 TTree.cxx:4138
 TTree.cxx:4139
 TTree.cxx:4140
 TTree.cxx:4141
 TTree.cxx:4142
 TTree.cxx:4143
 TTree.cxx:4144
 TTree.cxx:4145
 TTree.cxx:4146
 TTree.cxx:4147
 TTree.cxx:4148
 TTree.cxx:4149
 TTree.cxx:4150
 TTree.cxx:4151
 TTree.cxx:4152
 TTree.cxx:4153
 TTree.cxx:4154
 TTree.cxx:4155
 TTree.cxx:4156
 TTree.cxx:4157
 TTree.cxx:4158
 TTree.cxx:4159
 TTree.cxx:4160
 TTree.cxx:4161
 TTree.cxx:4162
 TTree.cxx:4163
 TTree.cxx:4164
 TTree.cxx:4165
 TTree.cxx:4166
 TTree.cxx:4167
 TTree.cxx:4168
 TTree.cxx:4169
 TTree.cxx:4170
 TTree.cxx:4171
 TTree.cxx:4172
 TTree.cxx:4173
 TTree.cxx:4174
 TTree.cxx:4175
 TTree.cxx:4176
 TTree.cxx:4177
 TTree.cxx:4178
 TTree.cxx:4179
 TTree.cxx:4180
 TTree.cxx:4181
 TTree.cxx:4182
 TTree.cxx:4183
 TTree.cxx:4184
 TTree.cxx:4185
 TTree.cxx:4186
 TTree.cxx:4187
 TTree.cxx:4188
 TTree.cxx:4189
 TTree.cxx:4190
 TTree.cxx:4191
 TTree.cxx:4192
 TTree.cxx:4193
 TTree.cxx:4194
 TTree.cxx:4195
 TTree.cxx:4196
 TTree.cxx:4197
 TTree.cxx:4198
 TTree.cxx:4199
 TTree.cxx:4200
 TTree.cxx:4201
 TTree.cxx:4202
 TTree.cxx:4203
 TTree.cxx:4204
 TTree.cxx:4205
 TTree.cxx:4206
 TTree.cxx:4207
 TTree.cxx:4208
 TTree.cxx:4209
 TTree.cxx:4210
 TTree.cxx:4211
 TTree.cxx:4212
 TTree.cxx:4213
 TTree.cxx:4214
 TTree.cxx:4215
 TTree.cxx:4216
 TTree.cxx:4217
 TTree.cxx:4218
 TTree.cxx:4219
 TTree.cxx:4220
 TTree.cxx:4221
 TTree.cxx:4222
 TTree.cxx:4223
 TTree.cxx:4224
 TTree.cxx:4225
 TTree.cxx:4226
 TTree.cxx:4227
 TTree.cxx:4228
 TTree.cxx:4229
 TTree.cxx:4230
 TTree.cxx:4231
 TTree.cxx:4232
 TTree.cxx:4233
 TTree.cxx:4234
 TTree.cxx:4235
 TTree.cxx:4236
 TTree.cxx:4237
 TTree.cxx:4238
 TTree.cxx:4239
 TTree.cxx:4240
 TTree.cxx:4241
 TTree.cxx:4242
 TTree.cxx:4243
 TTree.cxx:4244
 TTree.cxx:4245
 TTree.cxx:4246
 TTree.cxx:4247
 TTree.cxx:4248
 TTree.cxx:4249
 TTree.cxx:4250
 TTree.cxx:4251
 TTree.cxx:4252
 TTree.cxx:4253
 TTree.cxx:4254
 TTree.cxx:4255
 TTree.cxx:4256
 TTree.cxx:4257
 TTree.cxx:4258
 TTree.cxx:4259
 TTree.cxx:4260
 TTree.cxx:4261
 TTree.cxx:4262
 TTree.cxx:4263
 TTree.cxx:4264
 TTree.cxx:4265
 TTree.cxx:4266
 TTree.cxx:4267
 TTree.cxx:4268
 TTree.cxx:4269
 TTree.cxx:4270
 TTree.cxx:4271
 TTree.cxx:4272
 TTree.cxx:4273
 TTree.cxx:4274
 TTree.cxx:4275
 TTree.cxx:4276
 TTree.cxx:4277
 TTree.cxx:4278
 TTree.cxx:4279
 TTree.cxx:4280
 TTree.cxx:4281
 TTree.cxx:4282
 TTree.cxx:4283
 TTree.cxx:4284
 TTree.cxx:4285
 TTree.cxx:4286
 TTree.cxx:4287
 TTree.cxx:4288
 TTree.cxx:4289
 TTree.cxx:4290
 TTree.cxx:4291
 TTree.cxx:4292
 TTree.cxx:4293
 TTree.cxx:4294
 TTree.cxx:4295
 TTree.cxx:4296
 TTree.cxx:4297
 TTree.cxx:4298
 TTree.cxx:4299
 TTree.cxx:4300
 TTree.cxx:4301
 TTree.cxx:4302
 TTree.cxx:4303
 TTree.cxx:4304
 TTree.cxx:4305
 TTree.cxx:4306
 TTree.cxx:4307
 TTree.cxx:4308
 TTree.cxx:4309
 TTree.cxx:4310
 TTree.cxx:4311
 TTree.cxx:4312
 TTree.cxx:4313
 TTree.cxx:4314
 TTree.cxx:4315
 TTree.cxx:4316
 TTree.cxx:4317
 TTree.cxx:4318
 TTree.cxx:4319
 TTree.cxx:4320
 TTree.cxx:4321
 TTree.cxx:4322
 TTree.cxx:4323
 TTree.cxx:4324
 TTree.cxx:4325
 TTree.cxx:4326
 TTree.cxx:4327
 TTree.cxx:4328
 TTree.cxx:4329
 TTree.cxx:4330
 TTree.cxx:4331
 TTree.cxx:4332
 TTree.cxx:4333
 TTree.cxx:4334
 TTree.cxx:4335
 TTree.cxx:4336
 TTree.cxx:4337
 TTree.cxx:4338
 TTree.cxx:4339
 TTree.cxx:4340
 TTree.cxx:4341
 TTree.cxx:4342
 TTree.cxx:4343
 TTree.cxx:4344
 TTree.cxx:4345
 TTree.cxx:4346
 TTree.cxx:4347
 TTree.cxx:4348
 TTree.cxx:4349
 TTree.cxx:4350
 TTree.cxx:4351
 TTree.cxx:4352
 TTree.cxx:4353
 TTree.cxx:4354
 TTree.cxx:4355
 TTree.cxx:4356
 TTree.cxx:4357
 TTree.cxx:4358
 TTree.cxx:4359
 TTree.cxx:4360
 TTree.cxx:4361
 TTree.cxx:4362
 TTree.cxx:4363
 TTree.cxx:4364
 TTree.cxx:4365
 TTree.cxx:4366
 TTree.cxx:4367
 TTree.cxx:4368
 TTree.cxx:4369
 TTree.cxx:4370
 TTree.cxx:4371
 TTree.cxx:4372
 TTree.cxx:4373
 TTree.cxx:4374
 TTree.cxx:4375
 TTree.cxx:4376
 TTree.cxx:4377
 TTree.cxx:4378
 TTree.cxx:4379
 TTree.cxx:4380
 TTree.cxx:4381
 TTree.cxx:4382
 TTree.cxx:4383
 TTree.cxx:4384
 TTree.cxx:4385
 TTree.cxx:4386
 TTree.cxx:4387
 TTree.cxx:4388
 TTree.cxx:4389
 TTree.cxx:4390
 TTree.cxx:4391
 TTree.cxx:4392
 TTree.cxx:4393
 TTree.cxx:4394
 TTree.cxx:4395
 TTree.cxx:4396
 TTree.cxx:4397
 TTree.cxx:4398
 TTree.cxx:4399
 TTree.cxx:4400
 TTree.cxx:4401
 TTree.cxx:4402
 TTree.cxx:4403
 TTree.cxx:4404
 TTree.cxx:4405
 TTree.cxx:4406
 TTree.cxx:4407
 TTree.cxx:4408
 TTree.cxx:4409
 TTree.cxx:4410
 TTree.cxx:4411
 TTree.cxx:4412
 TTree.cxx:4413
 TTree.cxx:4414
 TTree.cxx:4415
 TTree.cxx:4416
 TTree.cxx:4417
 TTree.cxx:4418
 TTree.cxx:4419
 TTree.cxx:4420
 TTree.cxx:4421
 TTree.cxx:4422
 TTree.cxx:4423
 TTree.cxx:4424
 TTree.cxx:4425
 TTree.cxx:4426
 TTree.cxx:4427
 TTree.cxx:4428
 TTree.cxx:4429
 TTree.cxx:4430
 TTree.cxx:4431
 TTree.cxx:4432
 TTree.cxx:4433
 TTree.cxx:4434
 TTree.cxx:4435
 TTree.cxx:4436
 TTree.cxx:4437
 TTree.cxx:4438
 TTree.cxx:4439
 TTree.cxx:4440
 TTree.cxx:4441
 TTree.cxx:4442
 TTree.cxx:4443
 TTree.cxx:4444
 TTree.cxx:4445
 TTree.cxx:4446
 TTree.cxx:4447
 TTree.cxx:4448
 TTree.cxx:4449
 TTree.cxx:4450
 TTree.cxx:4451
 TTree.cxx:4452
 TTree.cxx:4453
 TTree.cxx:4454
 TTree.cxx:4455
 TTree.cxx:4456
 TTree.cxx:4457
 TTree.cxx:4458
 TTree.cxx:4459
 TTree.cxx:4460
 TTree.cxx:4461
 TTree.cxx:4462
 TTree.cxx:4463
 TTree.cxx:4464
 TTree.cxx:4465
 TTree.cxx:4466
 TTree.cxx:4467
 TTree.cxx:4468
 TTree.cxx:4469
 TTree.cxx:4470
 TTree.cxx:4471
 TTree.cxx:4472
 TTree.cxx:4473
 TTree.cxx:4474
 TTree.cxx:4475
 TTree.cxx:4476
 TTree.cxx:4477
 TTree.cxx:4478
 TTree.cxx:4479
 TTree.cxx:4480
 TTree.cxx:4481
 TTree.cxx:4482
 TTree.cxx:4483
 TTree.cxx:4484
 TTree.cxx:4485
 TTree.cxx:4486
 TTree.cxx:4487
 TTree.cxx:4488
 TTree.cxx:4489
 TTree.cxx:4490
 TTree.cxx:4491
 TTree.cxx:4492
 TTree.cxx:4493
 TTree.cxx:4494
 TTree.cxx:4495
 TTree.cxx:4496
 TTree.cxx:4497
 TTree.cxx:4498
 TTree.cxx:4499
 TTree.cxx:4500
 TTree.cxx:4501
 TTree.cxx:4502
 TTree.cxx:4503
 TTree.cxx:4504
 TTree.cxx:4505
 TTree.cxx:4506
 TTree.cxx:4507
 TTree.cxx:4508
 TTree.cxx:4509
 TTree.cxx:4510
 TTree.cxx:4511
 TTree.cxx:4512
 TTree.cxx:4513
 TTree.cxx:4514
 TTree.cxx:4515
 TTree.cxx:4516
 TTree.cxx:4517
 TTree.cxx:4518
 TTree.cxx:4519
 TTree.cxx:4520
 TTree.cxx:4521
 TTree.cxx:4522
 TTree.cxx:4523
 TTree.cxx:4524
 TTree.cxx:4525
 TTree.cxx:4526
 TTree.cxx:4527
 TTree.cxx:4528
 TTree.cxx:4529
 TTree.cxx:4530
 TTree.cxx:4531
 TTree.cxx:4532
 TTree.cxx:4533
 TTree.cxx:4534
 TTree.cxx:4535
 TTree.cxx:4536
 TTree.cxx:4537
 TTree.cxx:4538
 TTree.cxx:4539
 TTree.cxx:4540
 TTree.cxx:4541
 TTree.cxx:4542
 TTree.cxx:4543
 TTree.cxx:4544
 TTree.cxx:4545
 TTree.cxx:4546
 TTree.cxx:4547
 TTree.cxx:4548
 TTree.cxx:4549
 TTree.cxx:4550
 TTree.cxx:4551
 TTree.cxx:4552
 TTree.cxx:4553
 TTree.cxx:4554
 TTree.cxx:4555
 TTree.cxx:4556
 TTree.cxx:4557
 TTree.cxx:4558
 TTree.cxx:4559
 TTree.cxx:4560
 TTree.cxx:4561
 TTree.cxx:4562
 TTree.cxx:4563
 TTree.cxx:4564
 TTree.cxx:4565
 TTree.cxx:4566
 TTree.cxx:4567
 TTree.cxx:4568
 TTree.cxx:4569
 TTree.cxx:4570
 TTree.cxx:4571
 TTree.cxx:4572
 TTree.cxx:4573
 TTree.cxx:4574
 TTree.cxx:4575
 TTree.cxx:4576
 TTree.cxx:4577
 TTree.cxx:4578
 TTree.cxx:4579
 TTree.cxx:4580
 TTree.cxx:4581
 TTree.cxx:4582
 TTree.cxx:4583
 TTree.cxx:4584
 TTree.cxx:4585
 TTree.cxx:4586
 TTree.cxx:4587
 TTree.cxx:4588
 TTree.cxx:4589
 TTree.cxx:4590
 TTree.cxx:4591
 TTree.cxx:4592
 TTree.cxx:4593
 TTree.cxx:4594
 TTree.cxx:4595
 TTree.cxx:4596
 TTree.cxx:4597
 TTree.cxx:4598
 TTree.cxx:4599
 TTree.cxx:4600
 TTree.cxx:4601
 TTree.cxx:4602
 TTree.cxx:4603
 TTree.cxx:4604
 TTree.cxx:4605
 TTree.cxx:4606
 TTree.cxx:4607
 TTree.cxx:4608
 TTree.cxx:4609
 TTree.cxx:4610
 TTree.cxx:4611
 TTree.cxx:4612
 TTree.cxx:4613
 TTree.cxx:4614
 TTree.cxx:4615
 TTree.cxx:4616
 TTree.cxx:4617
 TTree.cxx:4618
 TTree.cxx:4619
 TTree.cxx:4620
 TTree.cxx:4621
 TTree.cxx:4622
 TTree.cxx:4623
 TTree.cxx:4624
 TTree.cxx:4625
 TTree.cxx:4626
 TTree.cxx:4627
 TTree.cxx:4628
 TTree.cxx:4629
 TTree.cxx:4630
 TTree.cxx:4631
 TTree.cxx:4632
 TTree.cxx:4633
 TTree.cxx:4634
 TTree.cxx:4635
 TTree.cxx:4636
 TTree.cxx:4637
 TTree.cxx:4638
 TTree.cxx:4639
 TTree.cxx:4640
 TTree.cxx:4641
 TTree.cxx:4642
 TTree.cxx:4643
 TTree.cxx:4644
 TTree.cxx:4645
 TTree.cxx:4646
 TTree.cxx:4647
 TTree.cxx:4648
 TTree.cxx:4649
 TTree.cxx:4650
 TTree.cxx:4651
 TTree.cxx:4652
 TTree.cxx:4653
 TTree.cxx:4654
 TTree.cxx:4655
 TTree.cxx:4656
 TTree.cxx:4657
 TTree.cxx:4658
 TTree.cxx:4659
 TTree.cxx:4660
 TTree.cxx:4661
 TTree.cxx:4662
 TTree.cxx:4663
 TTree.cxx:4664
 TTree.cxx:4665
 TTree.cxx:4666
 TTree.cxx:4667
 TTree.cxx:4668
 TTree.cxx:4669
 TTree.cxx:4670
 TTree.cxx:4671
 TTree.cxx:4672
 TTree.cxx:4673
 TTree.cxx:4674
 TTree.cxx:4675
 TTree.cxx:4676
 TTree.cxx:4677
 TTree.cxx:4678
 TTree.cxx:4679
 TTree.cxx:4680
 TTree.cxx:4681
 TTree.cxx:4682
 TTree.cxx:4683
 TTree.cxx:4684
 TTree.cxx:4685
 TTree.cxx:4686
 TTree.cxx:4687
 TTree.cxx:4688
 TTree.cxx:4689
 TTree.cxx:4690
 TTree.cxx:4691
 TTree.cxx:4692
 TTree.cxx:4693
 TTree.cxx:4694
 TTree.cxx:4695
 TTree.cxx:4696
 TTree.cxx:4697
 TTree.cxx:4698
 TTree.cxx:4699
 TTree.cxx:4700
 TTree.cxx:4701
 TTree.cxx:4702
 TTree.cxx:4703
 TTree.cxx:4704
 TTree.cxx:4705
 TTree.cxx:4706
 TTree.cxx:4707
 TTree.cxx:4708
 TTree.cxx:4709
 TTree.cxx:4710
 TTree.cxx:4711
 TTree.cxx:4712
 TTree.cxx:4713
 TTree.cxx:4714
 TTree.cxx:4715
 TTree.cxx:4716
 TTree.cxx:4717
 TTree.cxx:4718
 TTree.cxx:4719
 TTree.cxx:4720
 TTree.cxx:4721
 TTree.cxx:4722
 TTree.cxx:4723
 TTree.cxx:4724
 TTree.cxx:4725
 TTree.cxx:4726
 TTree.cxx:4727
 TTree.cxx:4728
 TTree.cxx:4729
 TTree.cxx:4730
 TTree.cxx:4731
 TTree.cxx:4732
 TTree.cxx:4733
 TTree.cxx:4734
 TTree.cxx:4735
 TTree.cxx:4736
 TTree.cxx:4737
 TTree.cxx:4738
 TTree.cxx:4739
 TTree.cxx:4740
 TTree.cxx:4741
 TTree.cxx:4742
 TTree.cxx:4743
 TTree.cxx:4744
 TTree.cxx:4745
 TTree.cxx:4746
 TTree.cxx:4747
 TTree.cxx:4748
 TTree.cxx:4749
 TTree.cxx:4750
 TTree.cxx:4751
 TTree.cxx:4752
 TTree.cxx:4753
 TTree.cxx:4754
 TTree.cxx:4755
 TTree.cxx:4756
 TTree.cxx:4757
 TTree.cxx:4758
 TTree.cxx:4759
 TTree.cxx:4760
 TTree.cxx:4761
 TTree.cxx:4762
 TTree.cxx:4763
 TTree.cxx:4764
 TTree.cxx:4765
 TTree.cxx:4766
 TTree.cxx:4767
 TTree.cxx:4768
 TTree.cxx:4769
 TTree.cxx:4770
 TTree.cxx:4771
 TTree.cxx:4772
 TTree.cxx:4773
 TTree.cxx:4774
 TTree.cxx:4775
 TTree.cxx:4776
 TTree.cxx:4777
 TTree.cxx:4778
 TTree.cxx:4779
 TTree.cxx:4780
 TTree.cxx:4781
 TTree.cxx:4782
 TTree.cxx:4783
 TTree.cxx:4784
 TTree.cxx:4785
 TTree.cxx:4786
 TTree.cxx:4787
 TTree.cxx:4788
 TTree.cxx:4789
 TTree.cxx:4790
 TTree.cxx:4791
 TTree.cxx:4792
 TTree.cxx:4793
 TTree.cxx:4794
 TTree.cxx:4795
 TTree.cxx:4796
 TTree.cxx:4797
 TTree.cxx:4798
 TTree.cxx:4799
 TTree.cxx:4800
 TTree.cxx:4801
 TTree.cxx:4802
 TTree.cxx:4803
 TTree.cxx:4804
 TTree.cxx:4805
 TTree.cxx:4806
 TTree.cxx:4807
 TTree.cxx:4808
 TTree.cxx:4809
 TTree.cxx:4810
 TTree.cxx:4811
 TTree.cxx:4812
 TTree.cxx:4813
 TTree.cxx:4814
 TTree.cxx:4815
 TTree.cxx:4816
 TTree.cxx:4817
 TTree.cxx:4818
 TTree.cxx:4819
 TTree.cxx:4820
 TTree.cxx:4821
 TTree.cxx:4822
 TTree.cxx:4823
 TTree.cxx:4824
 TTree.cxx:4825
 TTree.cxx:4826
 TTree.cxx:4827
 TTree.cxx:4828
 TTree.cxx:4829
 TTree.cxx:4830
 TTree.cxx:4831
 TTree.cxx:4832
 TTree.cxx:4833
 TTree.cxx:4834
 TTree.cxx:4835
 TTree.cxx:4836
 TTree.cxx:4837
 TTree.cxx:4838
 TTree.cxx:4839
 TTree.cxx:4840
 TTree.cxx:4841
 TTree.cxx:4842
 TTree.cxx:4843
 TTree.cxx:4844
 TTree.cxx:4845
 TTree.cxx:4846
 TTree.cxx:4847
 TTree.cxx:4848
 TTree.cxx:4849
 TTree.cxx:4850
 TTree.cxx:4851
 TTree.cxx:4852
 TTree.cxx:4853
 TTree.cxx:4854
 TTree.cxx:4855
 TTree.cxx:4856
 TTree.cxx:4857
 TTree.cxx:4858
 TTree.cxx:4859
 TTree.cxx:4860
 TTree.cxx:4861
 TTree.cxx:4862
 TTree.cxx:4863
 TTree.cxx:4864
 TTree.cxx:4865
 TTree.cxx:4866
 TTree.cxx:4867
 TTree.cxx:4868
 TTree.cxx:4869
 TTree.cxx:4870
 TTree.cxx:4871
 TTree.cxx:4872
 TTree.cxx:4873
 TTree.cxx:4874
 TTree.cxx:4875
 TTree.cxx:4876
 TTree.cxx:4877
 TTree.cxx:4878
 TTree.cxx:4879
 TTree.cxx:4880
 TTree.cxx:4881
 TTree.cxx:4882
 TTree.cxx:4883
 TTree.cxx:4884
 TTree.cxx:4885
 TTree.cxx:4886
 TTree.cxx:4887
 TTree.cxx:4888
 TTree.cxx:4889
 TTree.cxx:4890
 TTree.cxx:4891
 TTree.cxx:4892
 TTree.cxx:4893
 TTree.cxx:4894
 TTree.cxx:4895
 TTree.cxx:4896
 TTree.cxx:4897
 TTree.cxx:4898
 TTree.cxx:4899
 TTree.cxx:4900
 TTree.cxx:4901
 TTree.cxx:4902
 TTree.cxx:4903
 TTree.cxx:4904
 TTree.cxx:4905
 TTree.cxx:4906
 TTree.cxx:4907
 TTree.cxx:4908
 TTree.cxx:4909
 TTree.cxx:4910
 TTree.cxx:4911
 TTree.cxx:4912
 TTree.cxx:4913
 TTree.cxx:4914
 TTree.cxx:4915
 TTree.cxx:4916
 TTree.cxx:4917
 TTree.cxx:4918
 TTree.cxx:4919
 TTree.cxx:4920
 TTree.cxx:4921
 TTree.cxx:4922
 TTree.cxx:4923
 TTree.cxx:4924
 TTree.cxx:4925
 TTree.cxx:4926
 TTree.cxx:4927
 TTree.cxx:4928
 TTree.cxx:4929
 TTree.cxx:4930
 TTree.cxx:4931
 TTree.cxx:4932
 TTree.cxx:4933
 TTree.cxx:4934
 TTree.cxx:4935
 TTree.cxx:4936
 TTree.cxx:4937
 TTree.cxx:4938
 TTree.cxx:4939
 TTree.cxx:4940
 TTree.cxx:4941
 TTree.cxx:4942
 TTree.cxx:4943
 TTree.cxx:4944
 TTree.cxx:4945
 TTree.cxx:4946
 TTree.cxx:4947
 TTree.cxx:4948
 TTree.cxx:4949
 TTree.cxx:4950
 TTree.cxx:4951
 TTree.cxx:4952
 TTree.cxx:4953
 TTree.cxx:4954
 TTree.cxx:4955
 TTree.cxx:4956
 TTree.cxx:4957
 TTree.cxx:4958
 TTree.cxx:4959
 TTree.cxx:4960
 TTree.cxx:4961
 TTree.cxx:4962
 TTree.cxx:4963
 TTree.cxx:4964
 TTree.cxx:4965
 TTree.cxx:4966
 TTree.cxx:4967
 TTree.cxx:4968
 TTree.cxx:4969
 TTree.cxx:4970
 TTree.cxx:4971
 TTree.cxx:4972
 TTree.cxx:4973
 TTree.cxx:4974
 TTree.cxx:4975
 TTree.cxx:4976
 TTree.cxx:4977
 TTree.cxx:4978
 TTree.cxx:4979
 TTree.cxx:4980
 TTree.cxx:4981
 TTree.cxx:4982
 TTree.cxx:4983
 TTree.cxx:4984
 TTree.cxx:4985
 TTree.cxx:4986
 TTree.cxx:4987
 TTree.cxx:4988
 TTree.cxx:4989
 TTree.cxx:4990
 TTree.cxx:4991
 TTree.cxx:4992
 TTree.cxx:4993
 TTree.cxx:4994
 TTree.cxx:4995
 TTree.cxx:4996
 TTree.cxx:4997
 TTree.cxx:4998
 TTree.cxx:4999
 TTree.cxx:5000
 TTree.cxx:5001
 TTree.cxx:5002
 TTree.cxx:5003
 TTree.cxx:5004
 TTree.cxx:5005
 TTree.cxx:5006
 TTree.cxx:5007
 TTree.cxx:5008
 TTree.cxx:5009
 TTree.cxx:5010
 TTree.cxx:5011
 TTree.cxx:5012
 TTree.cxx:5013
 TTree.cxx:5014
 TTree.cxx:5015
 TTree.cxx:5016
 TTree.cxx:5017
 TTree.cxx:5018
 TTree.cxx:5019
 TTree.cxx:5020
 TTree.cxx:5021
 TTree.cxx:5022
 TTree.cxx:5023
 TTree.cxx:5024
 TTree.cxx:5025
 TTree.cxx:5026
 TTree.cxx:5027
 TTree.cxx:5028
 TTree.cxx:5029
 TTree.cxx:5030
 TTree.cxx:5031
 TTree.cxx:5032
 TTree.cxx:5033
 TTree.cxx:5034
 TTree.cxx:5035
 TTree.cxx:5036
 TTree.cxx:5037
 TTree.cxx:5038
 TTree.cxx:5039
 TTree.cxx:5040
 TTree.cxx:5041
 TTree.cxx:5042
 TTree.cxx:5043
 TTree.cxx:5044
 TTree.cxx:5045
 TTree.cxx:5046
 TTree.cxx:5047
 TTree.cxx:5048
 TTree.cxx:5049
 TTree.cxx:5050
 TTree.cxx:5051
 TTree.cxx:5052
 TTree.cxx:5053
 TTree.cxx:5054
 TTree.cxx:5055
 TTree.cxx:5056
 TTree.cxx:5057
 TTree.cxx:5058
 TTree.cxx:5059
 TTree.cxx:5060
 TTree.cxx:5061
 TTree.cxx:5062
 TTree.cxx:5063
 TTree.cxx:5064
 TTree.cxx:5065
 TTree.cxx:5066
 TTree.cxx:5067
 TTree.cxx:5068
 TTree.cxx:5069
 TTree.cxx:5070
 TTree.cxx:5071
 TTree.cxx:5072
 TTree.cxx:5073
 TTree.cxx:5074
 TTree.cxx:5075
 TTree.cxx:5076
 TTree.cxx:5077
 TTree.cxx:5078
 TTree.cxx:5079
 TTree.cxx:5080
 TTree.cxx:5081
 TTree.cxx:5082
 TTree.cxx:5083
 TTree.cxx:5084
 TTree.cxx:5085
 TTree.cxx:5086
 TTree.cxx:5087
 TTree.cxx:5088
 TTree.cxx:5089
 TTree.cxx:5090
 TTree.cxx:5091
 TTree.cxx:5092
 TTree.cxx:5093
 TTree.cxx:5094
 TTree.cxx:5095
 TTree.cxx:5096
 TTree.cxx:5097
 TTree.cxx:5098
 TTree.cxx:5099
 TTree.cxx:5100
 TTree.cxx:5101
 TTree.cxx:5102
 TTree.cxx:5103
 TTree.cxx:5104
 TTree.cxx:5105
 TTree.cxx:5106
 TTree.cxx:5107
 TTree.cxx:5108
 TTree.cxx:5109
 TTree.cxx:5110
 TTree.cxx:5111
 TTree.cxx:5112
 TTree.cxx:5113
 TTree.cxx:5114
 TTree.cxx:5115
 TTree.cxx:5116
 TTree.cxx:5117
 TTree.cxx:5118
 TTree.cxx:5119
 TTree.cxx:5120
 TTree.cxx:5121
 TTree.cxx:5122
 TTree.cxx:5123
 TTree.cxx:5124
 TTree.cxx:5125
 TTree.cxx:5126
 TTree.cxx:5127
 TTree.cxx:5128
 TTree.cxx:5129
 TTree.cxx:5130
 TTree.cxx:5131
 TTree.cxx:5132
 TTree.cxx:5133
 TTree.cxx:5134
 TTree.cxx:5135
 TTree.cxx:5136
 TTree.cxx:5137
 TTree.cxx:5138
 TTree.cxx:5139
 TTree.cxx:5140
 TTree.cxx:5141
 TTree.cxx:5142
 TTree.cxx:5143
 TTree.cxx:5144
 TTree.cxx:5145
 TTree.cxx:5146
 TTree.cxx:5147
 TTree.cxx:5148
 TTree.cxx:5149
 TTree.cxx:5150
 TTree.cxx:5151
 TTree.cxx:5152
 TTree.cxx:5153
 TTree.cxx:5154
 TTree.cxx:5155
 TTree.cxx:5156
 TTree.cxx:5157
 TTree.cxx:5158
 TTree.cxx:5159
 TTree.cxx:5160
 TTree.cxx:5161
 TTree.cxx:5162
 TTree.cxx:5163
 TTree.cxx:5164
 TTree.cxx:5165
 TTree.cxx:5166
 TTree.cxx:5167
 TTree.cxx:5168
 TTree.cxx:5169
 TTree.cxx:5170
 TTree.cxx:5171
 TTree.cxx:5172
 TTree.cxx:5173
 TTree.cxx:5174
 TTree.cxx:5175
 TTree.cxx:5176
 TTree.cxx:5177
 TTree.cxx:5178
 TTree.cxx:5179
 TTree.cxx:5180
 TTree.cxx:5181
 TTree.cxx:5182
 TTree.cxx:5183
 TTree.cxx:5184
 TTree.cxx:5185
 TTree.cxx:5186
 TTree.cxx:5187
 TTree.cxx:5188
 TTree.cxx:5189
 TTree.cxx:5190
 TTree.cxx:5191
 TTree.cxx:5192
 TTree.cxx:5193
 TTree.cxx:5194
 TTree.cxx:5195
 TTree.cxx:5196
 TTree.cxx:5197
 TTree.cxx:5198
 TTree.cxx:5199
 TTree.cxx:5200
 TTree.cxx:5201
 TTree.cxx:5202
 TTree.cxx:5203
 TTree.cxx:5204
 TTree.cxx:5205
 TTree.cxx:5206
 TTree.cxx:5207
 TTree.cxx:5208
 TTree.cxx:5209
 TTree.cxx:5210
 TTree.cxx:5211
 TTree.cxx:5212
 TTree.cxx:5213
 TTree.cxx:5214
 TTree.cxx:5215
 TTree.cxx:5216
 TTree.cxx:5217
 TTree.cxx:5218
 TTree.cxx:5219
 TTree.cxx:5220
 TTree.cxx:5221
 TTree.cxx:5222
 TTree.cxx:5223
 TTree.cxx:5224
 TTree.cxx:5225
 TTree.cxx:5226
 TTree.cxx:5227
 TTree.cxx:5228
 TTree.cxx:5229
 TTree.cxx:5230
 TTree.cxx:5231
 TTree.cxx:5232
 TTree.cxx:5233
 TTree.cxx:5234
 TTree.cxx:5235
 TTree.cxx:5236
 TTree.cxx:5237
 TTree.cxx:5238
 TTree.cxx:5239
 TTree.cxx:5240
 TTree.cxx:5241
 TTree.cxx:5242
 TTree.cxx:5243
 TTree.cxx:5244
 TTree.cxx:5245
 TTree.cxx:5246
 TTree.cxx:5247
 TTree.cxx:5248
 TTree.cxx:5249
 TTree.cxx:5250
 TTree.cxx:5251
 TTree.cxx:5252
 TTree.cxx:5253
 TTree.cxx:5254
 TTree.cxx:5255
 TTree.cxx:5256
 TTree.cxx:5257
 TTree.cxx:5258
 TTree.cxx:5259
 TTree.cxx:5260
 TTree.cxx:5261
 TTree.cxx:5262
 TTree.cxx:5263
 TTree.cxx:5264
 TTree.cxx:5265
 TTree.cxx:5266
 TTree.cxx:5267
 TTree.cxx:5268
 TTree.cxx:5269
 TTree.cxx:5270
 TTree.cxx:5271
 TTree.cxx:5272
 TTree.cxx:5273
 TTree.cxx:5274
 TTree.cxx:5275
 TTree.cxx:5276
 TTree.cxx:5277
 TTree.cxx:5278
 TTree.cxx:5279
 TTree.cxx:5280
 TTree.cxx:5281
 TTree.cxx:5282
 TTree.cxx:5283
 TTree.cxx:5284
 TTree.cxx:5285
 TTree.cxx:5286
 TTree.cxx:5287
 TTree.cxx:5288
 TTree.cxx:5289
 TTree.cxx:5290
 TTree.cxx:5291
 TTree.cxx:5292
 TTree.cxx:5293
 TTree.cxx:5294
 TTree.cxx:5295
 TTree.cxx:5296
 TTree.cxx:5297
 TTree.cxx:5298
 TTree.cxx:5299
 TTree.cxx:5300
 TTree.cxx:5301
 TTree.cxx:5302
 TTree.cxx:5303
 TTree.cxx:5304
 TTree.cxx:5305
 TTree.cxx:5306
 TTree.cxx:5307
 TTree.cxx:5308
 TTree.cxx:5309
 TTree.cxx:5310
 TTree.cxx:5311
 TTree.cxx:5312
 TTree.cxx:5313
 TTree.cxx:5314
 TTree.cxx:5315
 TTree.cxx:5316
 TTree.cxx:5317
 TTree.cxx:5318
 TTree.cxx:5319
 TTree.cxx:5320
 TTree.cxx:5321
 TTree.cxx:5322
 TTree.cxx:5323
 TTree.cxx:5324
 TTree.cxx:5325
 TTree.cxx:5326
 TTree.cxx:5327
 TTree.cxx:5328
 TTree.cxx:5329
 TTree.cxx:5330
 TTree.cxx:5331
 TTree.cxx:5332
 TTree.cxx:5333
 TTree.cxx:5334
 TTree.cxx:5335
 TTree.cxx:5336
 TTree.cxx:5337
 TTree.cxx:5338
 TTree.cxx:5339
 TTree.cxx:5340
 TTree.cxx:5341
 TTree.cxx:5342
 TTree.cxx:5343
 TTree.cxx:5344
 TTree.cxx:5345
 TTree.cxx:5346
 TTree.cxx:5347
 TTree.cxx:5348
 TTree.cxx:5349
 TTree.cxx:5350
 TTree.cxx:5351
 TTree.cxx:5352
 TTree.cxx:5353
 TTree.cxx:5354
 TTree.cxx:5355
 TTree.cxx:5356
 TTree.cxx:5357
 TTree.cxx:5358
 TTree.cxx:5359
 TTree.cxx:5360
 TTree.cxx:5361
 TTree.cxx:5362
 TTree.cxx:5363
 TTree.cxx:5364
 TTree.cxx:5365
 TTree.cxx:5366
 TTree.cxx:5367
 TTree.cxx:5368
 TTree.cxx:5369
 TTree.cxx:5370
 TTree.cxx:5371
 TTree.cxx:5372
 TTree.cxx:5373
 TTree.cxx:5374
 TTree.cxx:5375
 TTree.cxx:5376
 TTree.cxx:5377
 TTree.cxx:5378
 TTree.cxx:5379
 TTree.cxx:5380
 TTree.cxx:5381
 TTree.cxx:5382
 TTree.cxx:5383
 TTree.cxx:5384
 TTree.cxx:5385
 TTree.cxx:5386
 TTree.cxx:5387
 TTree.cxx:5388
 TTree.cxx:5389
 TTree.cxx:5390
 TTree.cxx:5391
 TTree.cxx:5392
 TTree.cxx:5393
 TTree.cxx:5394
 TTree.cxx:5395
 TTree.cxx:5396
 TTree.cxx:5397
 TTree.cxx:5398
 TTree.cxx:5399
 TTree.cxx:5400
 TTree.cxx:5401
 TTree.cxx:5402
 TTree.cxx:5403
 TTree.cxx:5404
 TTree.cxx:5405
 TTree.cxx:5406
 TTree.cxx:5407
 TTree.cxx:5408
 TTree.cxx:5409
 TTree.cxx:5410
 TTree.cxx:5411
 TTree.cxx:5412
 TTree.cxx:5413
 TTree.cxx:5414
 TTree.cxx:5415
 TTree.cxx:5416
 TTree.cxx:5417
 TTree.cxx:5418
 TTree.cxx:5419
 TTree.cxx:5420
 TTree.cxx:5421
 TTree.cxx:5422
 TTree.cxx:5423
 TTree.cxx:5424
 TTree.cxx:5425
 TTree.cxx:5426
 TTree.cxx:5427
 TTree.cxx:5428
 TTree.cxx:5429
 TTree.cxx:5430
 TTree.cxx:5431
 TTree.cxx:5432
 TTree.cxx:5433
 TTree.cxx:5434
 TTree.cxx:5435
 TTree.cxx:5436
 TTree.cxx:5437
 TTree.cxx:5438
 TTree.cxx:5439
 TTree.cxx:5440
 TTree.cxx:5441
 TTree.cxx:5442
 TTree.cxx:5443
 TTree.cxx:5444
 TTree.cxx:5445
 TTree.cxx:5446
 TTree.cxx:5447
 TTree.cxx:5448
 TTree.cxx:5449
 TTree.cxx:5450
 TTree.cxx:5451
 TTree.cxx:5452
 TTree.cxx:5453
 TTree.cxx:5454
 TTree.cxx:5455
 TTree.cxx:5456
 TTree.cxx:5457
 TTree.cxx:5458
 TTree.cxx:5459
 TTree.cxx:5460
 TTree.cxx:5461
 TTree.cxx:5462
 TTree.cxx:5463
 TTree.cxx:5464
 TTree.cxx:5465
 TTree.cxx:5466
 TTree.cxx:5467
 TTree.cxx:5468
 TTree.cxx:5469
 TTree.cxx:5470
 TTree.cxx:5471
 TTree.cxx:5472
 TTree.cxx:5473
 TTree.cxx:5474
 TTree.cxx:5475
 TTree.cxx:5476
 TTree.cxx:5477
 TTree.cxx:5478
 TTree.cxx:5479
 TTree.cxx:5480
 TTree.cxx:5481
 TTree.cxx:5482
 TTree.cxx:5483
 TTree.cxx:5484
 TTree.cxx:5485
 TTree.cxx:5486
 TTree.cxx:5487
 TTree.cxx:5488
 TTree.cxx:5489
 TTree.cxx:5490
 TTree.cxx:5491
 TTree.cxx:5492
 TTree.cxx:5493
 TTree.cxx:5494
 TTree.cxx:5495
 TTree.cxx:5496
 TTree.cxx:5497
 TTree.cxx:5498
 TTree.cxx:5499
 TTree.cxx:5500
 TTree.cxx:5501
 TTree.cxx:5502
 TTree.cxx:5503
 TTree.cxx:5504
 TTree.cxx:5505
 TTree.cxx:5506
 TTree.cxx:5507
 TTree.cxx:5508
 TTree.cxx:5509
 TTree.cxx:5510
 TTree.cxx:5511
 TTree.cxx:5512
 TTree.cxx:5513
 TTree.cxx:5514
 TTree.cxx:5515
 TTree.cxx:5516
 TTree.cxx:5517
 TTree.cxx:5518
 TTree.cxx:5519
 TTree.cxx:5520
 TTree.cxx:5521
 TTree.cxx:5522
 TTree.cxx:5523
 TTree.cxx:5524
 TTree.cxx:5525
 TTree.cxx:5526
 TTree.cxx:5527
 TTree.cxx:5528
 TTree.cxx:5529
 TTree.cxx:5530
 TTree.cxx:5531
 TTree.cxx:5532
 TTree.cxx:5533
 TTree.cxx:5534
 TTree.cxx:5535
 TTree.cxx:5536
 TTree.cxx:5537
 TTree.cxx:5538
 TTree.cxx:5539
 TTree.cxx:5540
 TTree.cxx:5541
 TTree.cxx:5542
 TTree.cxx:5543
 TTree.cxx:5544
 TTree.cxx:5545
 TTree.cxx:5546
 TTree.cxx:5547
 TTree.cxx:5548
 TTree.cxx:5549
 TTree.cxx:5550
 TTree.cxx:5551
 TTree.cxx:5552
 TTree.cxx:5553
 TTree.cxx:5554
 TTree.cxx:5555
 TTree.cxx:5556
 TTree.cxx:5557
 TTree.cxx:5558
 TTree.cxx:5559
 TTree.cxx:5560
 TTree.cxx:5561
 TTree.cxx:5562
 TTree.cxx:5563
 TTree.cxx:5564
 TTree.cxx:5565
 TTree.cxx:5566
 TTree.cxx:5567
 TTree.cxx:5568
 TTree.cxx:5569
 TTree.cxx:5570
 TTree.cxx:5571
 TTree.cxx:5572
 TTree.cxx:5573
 TTree.cxx:5574
 TTree.cxx:5575
 TTree.cxx:5576
 TTree.cxx:5577
 TTree.cxx:5578
 TTree.cxx:5579
 TTree.cxx:5580
 TTree.cxx:5581
 TTree.cxx:5582
 TTree.cxx:5583
 TTree.cxx:5584
 TTree.cxx:5585
 TTree.cxx:5586
 TTree.cxx:5587
 TTree.cxx:5588
 TTree.cxx:5589
 TTree.cxx:5590
 TTree.cxx:5591
 TTree.cxx:5592
 TTree.cxx:5593
 TTree.cxx:5594
 TTree.cxx:5595
 TTree.cxx:5596
 TTree.cxx:5597
 TTree.cxx:5598
 TTree.cxx:5599
 TTree.cxx:5600
 TTree.cxx:5601
 TTree.cxx:5602
 TTree.cxx:5603
 TTree.cxx:5604
 TTree.cxx:5605
 TTree.cxx:5606
 TTree.cxx:5607
 TTree.cxx:5608
 TTree.cxx:5609
 TTree.cxx:5610
 TTree.cxx:5611
 TTree.cxx:5612
 TTree.cxx:5613
 TTree.cxx:5614
 TTree.cxx:5615
 TTree.cxx:5616
 TTree.cxx:5617
 TTree.cxx:5618
 TTree.cxx:5619
 TTree.cxx:5620
 TTree.cxx:5621
 TTree.cxx:5622
 TTree.cxx:5623
 TTree.cxx:5624
 TTree.cxx:5625
 TTree.cxx:5626
 TTree.cxx:5627
 TTree.cxx:5628
 TTree.cxx:5629
 TTree.cxx:5630
 TTree.cxx:5631
 TTree.cxx:5632
 TTree.cxx:5633
 TTree.cxx:5634
 TTree.cxx:5635
 TTree.cxx:5636
 TTree.cxx:5637
 TTree.cxx:5638
 TTree.cxx:5639
 TTree.cxx:5640
 TTree.cxx:5641
 TTree.cxx:5642
 TTree.cxx:5643
 TTree.cxx:5644
 TTree.cxx:5645
 TTree.cxx:5646
 TTree.cxx:5647
 TTree.cxx:5648
 TTree.cxx:5649
 TTree.cxx:5650
 TTree.cxx:5651
 TTree.cxx:5652
 TTree.cxx:5653
 TTree.cxx:5654
 TTree.cxx:5655
 TTree.cxx:5656
 TTree.cxx:5657
 TTree.cxx:5658
 TTree.cxx:5659
 TTree.cxx:5660
 TTree.cxx:5661
 TTree.cxx:5662
 TTree.cxx:5663
 TTree.cxx:5664
 TTree.cxx:5665
 TTree.cxx:5666
 TTree.cxx:5667
 TTree.cxx:5668
 TTree.cxx:5669
 TTree.cxx:5670
 TTree.cxx:5671
 TTree.cxx:5672
 TTree.cxx:5673
 TTree.cxx:5674
 TTree.cxx:5675
 TTree.cxx:5676
 TTree.cxx:5677
 TTree.cxx:5678
 TTree.cxx:5679
 TTree.cxx:5680
 TTree.cxx:5681
 TTree.cxx:5682
 TTree.cxx:5683
 TTree.cxx:5684
 TTree.cxx:5685
 TTree.cxx:5686
 TTree.cxx:5687
 TTree.cxx:5688
 TTree.cxx:5689
 TTree.cxx:5690
 TTree.cxx:5691
 TTree.cxx:5692
 TTree.cxx:5693
 TTree.cxx:5694
 TTree.cxx:5695
 TTree.cxx:5696
 TTree.cxx:5697
 TTree.cxx:5698
 TTree.cxx:5699
 TTree.cxx:5700
 TTree.cxx:5701
 TTree.cxx:5702
 TTree.cxx:5703
 TTree.cxx:5704
 TTree.cxx:5705
 TTree.cxx:5706
 TTree.cxx:5707
 TTree.cxx:5708
 TTree.cxx:5709
 TTree.cxx:5710
 TTree.cxx:5711
 TTree.cxx:5712
 TTree.cxx:5713
 TTree.cxx:5714
 TTree.cxx:5715
 TTree.cxx:5716
 TTree.cxx:5717
 TTree.cxx:5718
 TTree.cxx:5719
 TTree.cxx:5720
 TTree.cxx:5721
 TTree.cxx:5722
 TTree.cxx:5723
 TTree.cxx:5724
 TTree.cxx:5725
 TTree.cxx:5726
 TTree.cxx:5727
 TTree.cxx:5728
 TTree.cxx:5729
 TTree.cxx:5730
 TTree.cxx:5731
 TTree.cxx:5732
 TTree.cxx:5733
 TTree.cxx:5734
 TTree.cxx:5735
 TTree.cxx:5736
 TTree.cxx:5737
 TTree.cxx:5738
 TTree.cxx:5739
 TTree.cxx:5740
 TTree.cxx:5741
 TTree.cxx:5742
 TTree.cxx:5743
 TTree.cxx:5744
 TTree.cxx:5745
 TTree.cxx:5746
 TTree.cxx:5747
 TTree.cxx:5748
 TTree.cxx:5749
 TTree.cxx:5750
 TTree.cxx:5751
 TTree.cxx:5752
 TTree.cxx:5753
 TTree.cxx:5754
 TTree.cxx:5755
 TTree.cxx:5756
 TTree.cxx:5757
 TTree.cxx:5758
 TTree.cxx:5759
 TTree.cxx:5760
 TTree.cxx:5761
 TTree.cxx:5762
 TTree.cxx:5763
 TTree.cxx:5764
 TTree.cxx:5765
 TTree.cxx:5766
 TTree.cxx:5767
 TTree.cxx:5768
 TTree.cxx:5769
 TTree.cxx:5770
 TTree.cxx:5771
 TTree.cxx:5772
 TTree.cxx:5773
 TTree.cxx:5774
 TTree.cxx:5775
 TTree.cxx:5776
 TTree.cxx:5777
 TTree.cxx:5778
 TTree.cxx:5779
 TTree.cxx:5780
 TTree.cxx:5781
 TTree.cxx:5782
 TTree.cxx:5783
 TTree.cxx:5784
 TTree.cxx:5785
 TTree.cxx:5786
 TTree.cxx:5787
 TTree.cxx:5788
 TTree.cxx:5789
 TTree.cxx:5790
 TTree.cxx:5791
 TTree.cxx:5792
 TTree.cxx:5793
 TTree.cxx:5794
 TTree.cxx:5795
 TTree.cxx:5796
 TTree.cxx:5797
 TTree.cxx:5798
 TTree.cxx:5799
 TTree.cxx:5800
 TTree.cxx:5801
 TTree.cxx:5802
 TTree.cxx:5803
 TTree.cxx:5804
 TTree.cxx:5805
 TTree.cxx:5806
 TTree.cxx:5807
 TTree.cxx:5808
 TTree.cxx:5809
 TTree.cxx:5810
 TTree.cxx:5811
 TTree.cxx:5812
 TTree.cxx:5813
 TTree.cxx:5814
 TTree.cxx:5815
 TTree.cxx:5816
 TTree.cxx:5817
 TTree.cxx:5818
 TTree.cxx:5819
 TTree.cxx:5820
 TTree.cxx:5821
 TTree.cxx:5822
 TTree.cxx:5823
 TTree.cxx:5824
 TTree.cxx:5825
 TTree.cxx:5826
 TTree.cxx:5827
 TTree.cxx:5828
 TTree.cxx:5829
 TTree.cxx:5830
 TTree.cxx:5831
 TTree.cxx:5832
 TTree.cxx:5833
 TTree.cxx:5834
 TTree.cxx:5835
 TTree.cxx:5836
 TTree.cxx:5837
 TTree.cxx:5838
 TTree.cxx:5839
 TTree.cxx:5840
 TTree.cxx:5841
 TTree.cxx:5842
 TTree.cxx:5843
 TTree.cxx:5844
 TTree.cxx:5845
 TTree.cxx:5846
 TTree.cxx:5847
 TTree.cxx:5848
 TTree.cxx:5849
 TTree.cxx:5850
 TTree.cxx:5851
 TTree.cxx:5852
 TTree.cxx:5853
 TTree.cxx:5854
 TTree.cxx:5855
 TTree.cxx:5856
 TTree.cxx:5857
 TTree.cxx:5858
 TTree.cxx:5859
 TTree.cxx:5860
 TTree.cxx:5861
 TTree.cxx:5862
 TTree.cxx:5863
 TTree.cxx:5864
 TTree.cxx:5865
 TTree.cxx:5866
 TTree.cxx:5867
 TTree.cxx:5868
 TTree.cxx:5869
 TTree.cxx:5870
 TTree.cxx:5871
 TTree.cxx:5872
 TTree.cxx:5873
 TTree.cxx:5874
 TTree.cxx:5875
 TTree.cxx:5876
 TTree.cxx:5877
 TTree.cxx:5878
 TTree.cxx:5879
 TTree.cxx:5880
 TTree.cxx:5881
 TTree.cxx:5882
 TTree.cxx:5883
 TTree.cxx:5884
 TTree.cxx:5885
 TTree.cxx:5886
 TTree.cxx:5887
 TTree.cxx:5888
 TTree.cxx:5889
 TTree.cxx:5890
 TTree.cxx:5891
 TTree.cxx:5892
 TTree.cxx:5893
 TTree.cxx:5894
 TTree.cxx:5895
 TTree.cxx:5896
 TTree.cxx:5897
 TTree.cxx:5898
 TTree.cxx:5899
 TTree.cxx:5900
 TTree.cxx:5901
 TTree.cxx:5902
 TTree.cxx:5903
 TTree.cxx:5904
 TTree.cxx:5905
 TTree.cxx:5906
 TTree.cxx:5907
 TTree.cxx:5908
 TTree.cxx:5909
 TTree.cxx:5910
 TTree.cxx:5911
 TTree.cxx:5912
 TTree.cxx:5913
 TTree.cxx:5914
 TTree.cxx:5915
 TTree.cxx:5916
 TTree.cxx:5917
 TTree.cxx:5918
 TTree.cxx:5919
 TTree.cxx:5920
 TTree.cxx:5921
 TTree.cxx:5922
 TTree.cxx:5923
 TTree.cxx:5924
 TTree.cxx:5925
 TTree.cxx:5926
 TTree.cxx:5927
 TTree.cxx:5928
 TTree.cxx:5929
 TTree.cxx:5930
 TTree.cxx:5931
 TTree.cxx:5932
 TTree.cxx:5933
 TTree.cxx:5934
 TTree.cxx:5935
 TTree.cxx:5936
 TTree.cxx:5937
 TTree.cxx:5938
 TTree.cxx:5939
 TTree.cxx:5940
 TTree.cxx:5941
 TTree.cxx:5942
 TTree.cxx:5943
 TTree.cxx:5944
 TTree.cxx:5945
 TTree.cxx:5946
 TTree.cxx:5947
 TTree.cxx:5948
 TTree.cxx:5949
 TTree.cxx:5950
 TTree.cxx:5951
 TTree.cxx:5952
 TTree.cxx:5953
 TTree.cxx:5954
 TTree.cxx:5955
 TTree.cxx:5956
 TTree.cxx:5957
 TTree.cxx:5958
 TTree.cxx:5959
 TTree.cxx:5960
 TTree.cxx:5961
 TTree.cxx:5962
 TTree.cxx:5963
 TTree.cxx:5964
 TTree.cxx:5965
 TTree.cxx:5966
 TTree.cxx:5967
 TTree.cxx:5968
 TTree.cxx:5969
 TTree.cxx:5970
 TTree.cxx:5971
 TTree.cxx:5972
 TTree.cxx:5973
 TTree.cxx:5974
 TTree.cxx:5975
 TTree.cxx:5976
 TTree.cxx:5977
 TTree.cxx:5978
 TTree.cxx:5979
 TTree.cxx:5980
 TTree.cxx:5981
 TTree.cxx:5982
 TTree.cxx:5983
 TTree.cxx:5984
 TTree.cxx:5985
 TTree.cxx:5986
 TTree.cxx:5987
 TTree.cxx:5988
 TTree.cxx:5989
 TTree.cxx:5990
 TTree.cxx:5991
 TTree.cxx:5992
 TTree.cxx:5993
 TTree.cxx:5994
 TTree.cxx:5995
 TTree.cxx:5996
 TTree.cxx:5997
 TTree.cxx:5998
 TTree.cxx:5999
 TTree.cxx:6000
 TTree.cxx:6001
 TTree.cxx:6002
 TTree.cxx:6003
 TTree.cxx:6004
 TTree.cxx:6005
 TTree.cxx:6006
 TTree.cxx:6007
 TTree.cxx:6008
 TTree.cxx:6009
 TTree.cxx:6010
 TTree.cxx:6011
 TTree.cxx:6012
 TTree.cxx:6013
 TTree.cxx:6014
 TTree.cxx:6015
 TTree.cxx:6016
 TTree.cxx:6017
 TTree.cxx:6018
 TTree.cxx:6019
 TTree.cxx:6020
 TTree.cxx:6021
 TTree.cxx:6022
 TTree.cxx:6023
 TTree.cxx:6024
 TTree.cxx:6025
 TTree.cxx:6026
 TTree.cxx:6027
 TTree.cxx:6028
 TTree.cxx:6029
 TTree.cxx:6030
 TTree.cxx:6031
 TTree.cxx:6032
 TTree.cxx:6033
 TTree.cxx:6034
 TTree.cxx:6035
 TTree.cxx:6036
 TTree.cxx:6037
 TTree.cxx:6038
 TTree.cxx:6039
 TTree.cxx:6040
 TTree.cxx:6041
 TTree.cxx:6042
 TTree.cxx:6043
 TTree.cxx:6044
 TTree.cxx:6045
 TTree.cxx:6046
 TTree.cxx:6047
 TTree.cxx:6048
 TTree.cxx:6049
 TTree.cxx:6050
 TTree.cxx:6051
 TTree.cxx:6052
 TTree.cxx:6053
 TTree.cxx:6054
 TTree.cxx:6055
 TTree.cxx:6056
 TTree.cxx:6057
 TTree.cxx:6058
 TTree.cxx:6059
 TTree.cxx:6060
 TTree.cxx:6061
 TTree.cxx:6062
 TTree.cxx:6063
 TTree.cxx:6064
 TTree.cxx:6065
 TTree.cxx:6066
 TTree.cxx:6067
 TTree.cxx:6068
 TTree.cxx:6069
 TTree.cxx:6070
 TTree.cxx:6071
 TTree.cxx:6072
 TTree.cxx:6073
 TTree.cxx:6074
 TTree.cxx:6075
 TTree.cxx:6076
 TTree.cxx:6077
 TTree.cxx:6078
 TTree.cxx:6079
 TTree.cxx:6080
 TTree.cxx:6081
 TTree.cxx:6082
 TTree.cxx:6083
 TTree.cxx:6084
 TTree.cxx:6085
 TTree.cxx:6086
 TTree.cxx:6087
 TTree.cxx:6088
 TTree.cxx:6089
 TTree.cxx:6090
 TTree.cxx:6091
 TTree.cxx:6092
 TTree.cxx:6093
 TTree.cxx:6094
 TTree.cxx:6095
 TTree.cxx:6096
 TTree.cxx:6097
 TTree.cxx:6098
 TTree.cxx:6099
 TTree.cxx:6100
 TTree.cxx:6101
 TTree.cxx:6102
 TTree.cxx:6103
 TTree.cxx:6104
 TTree.cxx:6105
 TTree.cxx:6106
 TTree.cxx:6107
 TTree.cxx:6108
 TTree.cxx:6109
 TTree.cxx:6110
 TTree.cxx:6111
 TTree.cxx:6112
 TTree.cxx:6113
 TTree.cxx:6114
 TTree.cxx:6115
 TTree.cxx:6116
 TTree.cxx:6117
 TTree.cxx:6118
 TTree.cxx:6119
 TTree.cxx:6120
 TTree.cxx:6121
 TTree.cxx:6122
 TTree.cxx:6123
 TTree.cxx:6124
 TTree.cxx:6125
 TTree.cxx:6126
 TTree.cxx:6127
 TTree.cxx:6128
 TTree.cxx:6129
 TTree.cxx:6130
 TTree.cxx:6131
 TTree.cxx:6132
 TTree.cxx:6133
 TTree.cxx:6134
 TTree.cxx:6135
 TTree.cxx:6136
 TTree.cxx:6137
 TTree.cxx:6138
 TTree.cxx:6139
 TTree.cxx:6140
 TTree.cxx:6141
 TTree.cxx:6142
 TTree.cxx:6143
 TTree.cxx:6144
 TTree.cxx:6145
 TTree.cxx:6146
 TTree.cxx:6147
 TTree.cxx:6148
 TTree.cxx:6149
 TTree.cxx:6150
 TTree.cxx:6151
 TTree.cxx:6152
 TTree.cxx:6153
 TTree.cxx:6154
 TTree.cxx:6155
 TTree.cxx:6156
 TTree.cxx:6157
 TTree.cxx:6158
 TTree.cxx:6159
 TTree.cxx:6160
 TTree.cxx:6161
 TTree.cxx:6162
 TTree.cxx:6163
 TTree.cxx:6164
 TTree.cxx:6165
 TTree.cxx:6166
 TTree.cxx:6167
 TTree.cxx:6168
 TTree.cxx:6169
 TTree.cxx:6170
 TTree.cxx:6171
 TTree.cxx:6172
 TTree.cxx:6173
 TTree.cxx:6174
 TTree.cxx:6175
 TTree.cxx:6176
 TTree.cxx:6177
 TTree.cxx:6178
 TTree.cxx:6179
 TTree.cxx:6180
 TTree.cxx:6181
 TTree.cxx:6182
 TTree.cxx:6183
 TTree.cxx:6184
 TTree.cxx:6185
 TTree.cxx:6186
 TTree.cxx:6187
 TTree.cxx:6188
 TTree.cxx:6189
 TTree.cxx:6190
 TTree.cxx:6191
 TTree.cxx:6192
 TTree.cxx:6193
 TTree.cxx:6194
 TTree.cxx:6195
 TTree.cxx:6196
 TTree.cxx:6197
 TTree.cxx:6198
 TTree.cxx:6199
 TTree.cxx:6200
 TTree.cxx:6201
 TTree.cxx:6202
 TTree.cxx:6203
 TTree.cxx:6204
 TTree.cxx:6205
 TTree.cxx:6206
 TTree.cxx:6207
 TTree.cxx:6208
 TTree.cxx:6209
 TTree.cxx:6210
 TTree.cxx:6211
 TTree.cxx:6212
 TTree.cxx:6213
 TTree.cxx:6214
 TTree.cxx:6215
 TTree.cxx:6216
 TTree.cxx:6217
 TTree.cxx:6218
 TTree.cxx:6219
 TTree.cxx:6220
 TTree.cxx:6221
 TTree.cxx:6222
 TTree.cxx:6223
 TTree.cxx:6224
 TTree.cxx:6225
 TTree.cxx:6226
 TTree.cxx:6227
 TTree.cxx:6228
 TTree.cxx:6229
 TTree.cxx:6230
 TTree.cxx:6231
 TTree.cxx:6232
 TTree.cxx:6233
 TTree.cxx:6234
 TTree.cxx:6235
 TTree.cxx:6236
 TTree.cxx:6237
 TTree.cxx:6238
 TTree.cxx:6239
 TTree.cxx:6240
 TTree.cxx:6241
 TTree.cxx:6242
 TTree.cxx:6243
 TTree.cxx:6244
 TTree.cxx:6245
 TTree.cxx:6246
 TTree.cxx:6247
 TTree.cxx:6248
 TTree.cxx:6249
 TTree.cxx:6250
 TTree.cxx:6251
 TTree.cxx:6252
 TTree.cxx:6253
 TTree.cxx:6254
 TTree.cxx:6255
 TTree.cxx:6256
 TTree.cxx:6257
 TTree.cxx:6258
 TTree.cxx:6259
 TTree.cxx:6260
 TTree.cxx:6261
 TTree.cxx:6262
 TTree.cxx:6263
 TTree.cxx:6264
 TTree.cxx:6265
 TTree.cxx:6266
 TTree.cxx:6267
 TTree.cxx:6268
 TTree.cxx:6269
 TTree.cxx:6270
 TTree.cxx:6271
 TTree.cxx:6272
 TTree.cxx:6273
 TTree.cxx:6274
 TTree.cxx:6275
 TTree.cxx:6276
 TTree.cxx:6277
 TTree.cxx:6278
 TTree.cxx:6279
 TTree.cxx:6280
 TTree.cxx:6281
 TTree.cxx:6282
 TTree.cxx:6283
 TTree.cxx:6284
 TTree.cxx:6285
 TTree.cxx:6286
 TTree.cxx:6287
 TTree.cxx:6288
 TTree.cxx:6289
 TTree.cxx:6290
 TTree.cxx:6291
 TTree.cxx:6292
 TTree.cxx:6293
 TTree.cxx:6294
 TTree.cxx:6295
 TTree.cxx:6296
 TTree.cxx:6297
 TTree.cxx:6298
 TTree.cxx:6299
 TTree.cxx:6300
 TTree.cxx:6301
 TTree.cxx:6302
 TTree.cxx:6303
 TTree.cxx:6304
 TTree.cxx:6305
 TTree.cxx:6306
 TTree.cxx:6307
 TTree.cxx:6308
 TTree.cxx:6309
 TTree.cxx:6310
 TTree.cxx:6311
 TTree.cxx:6312
 TTree.cxx:6313
 TTree.cxx:6314
 TTree.cxx:6315
 TTree.cxx:6316
 TTree.cxx:6317
 TTree.cxx:6318
 TTree.cxx:6319
 TTree.cxx:6320
 TTree.cxx:6321
 TTree.cxx:6322
 TTree.cxx:6323
 TTree.cxx:6324
 TTree.cxx:6325
 TTree.cxx:6326
 TTree.cxx:6327
 TTree.cxx:6328
 TTree.cxx:6329
 TTree.cxx:6330
 TTree.cxx:6331
 TTree.cxx:6332
 TTree.cxx:6333
 TTree.cxx:6334
 TTree.cxx:6335
 TTree.cxx:6336
 TTree.cxx:6337
 TTree.cxx:6338
 TTree.cxx:6339
 TTree.cxx:6340
 TTree.cxx:6341
 TTree.cxx:6342
 TTree.cxx:6343
 TTree.cxx:6344
 TTree.cxx:6345
 TTree.cxx:6346
 TTree.cxx:6347
 TTree.cxx:6348
 TTree.cxx:6349
 TTree.cxx:6350
 TTree.cxx:6351
 TTree.cxx:6352
 TTree.cxx:6353
 TTree.cxx:6354
 TTree.cxx:6355
 TTree.cxx:6356
 TTree.cxx:6357
 TTree.cxx:6358
 TTree.cxx:6359
 TTree.cxx:6360
 TTree.cxx:6361
 TTree.cxx:6362
 TTree.cxx:6363
 TTree.cxx:6364
 TTree.cxx:6365
 TTree.cxx:6366
 TTree.cxx:6367
 TTree.cxx:6368
 TTree.cxx:6369
 TTree.cxx:6370
 TTree.cxx:6371
 TTree.cxx:6372
 TTree.cxx:6373
 TTree.cxx:6374
 TTree.cxx:6375
 TTree.cxx:6376
 TTree.cxx:6377
 TTree.cxx:6378
 TTree.cxx:6379
 TTree.cxx:6380
 TTree.cxx:6381
 TTree.cxx:6382
 TTree.cxx:6383
 TTree.cxx:6384
 TTree.cxx:6385
 TTree.cxx:6386
 TTree.cxx:6387
 TTree.cxx:6388
 TTree.cxx:6389
 TTree.cxx:6390
 TTree.cxx:6391
 TTree.cxx:6392
 TTree.cxx:6393
 TTree.cxx:6394
 TTree.cxx:6395
 TTree.cxx:6396
 TTree.cxx:6397
 TTree.cxx:6398
 TTree.cxx:6399
 TTree.cxx:6400
 TTree.cxx:6401
 TTree.cxx:6402
 TTree.cxx:6403
 TTree.cxx:6404
 TTree.cxx:6405
 TTree.cxx:6406
 TTree.cxx:6407
 TTree.cxx:6408
 TTree.cxx:6409
 TTree.cxx:6410
 TTree.cxx:6411
 TTree.cxx:6412
 TTree.cxx:6413
 TTree.cxx:6414
 TTree.cxx:6415
 TTree.cxx:6416
 TTree.cxx:6417
 TTree.cxx:6418
 TTree.cxx:6419
 TTree.cxx:6420
 TTree.cxx:6421
 TTree.cxx:6422
 TTree.cxx:6423
 TTree.cxx:6424
 TTree.cxx:6425
 TTree.cxx:6426
 TTree.cxx:6427
 TTree.cxx:6428
 TTree.cxx:6429
 TTree.cxx:6430
 TTree.cxx:6431
 TTree.cxx:6432
 TTree.cxx:6433
 TTree.cxx:6434
 TTree.cxx:6435
 TTree.cxx:6436
 TTree.cxx:6437
 TTree.cxx:6438
 TTree.cxx:6439
 TTree.cxx:6440
 TTree.cxx:6441
 TTree.cxx:6442
 TTree.cxx:6443
 TTree.cxx:6444
 TTree.cxx:6445
 TTree.cxx:6446
 TTree.cxx:6447
 TTree.cxx:6448
 TTree.cxx:6449
 TTree.cxx:6450
 TTree.cxx:6451
 TTree.cxx:6452
 TTree.cxx:6453
 TTree.cxx:6454
 TTree.cxx:6455
 TTree.cxx:6456
 TTree.cxx:6457
 TTree.cxx:6458
 TTree.cxx:6459
 TTree.cxx:6460
 TTree.cxx:6461
 TTree.cxx:6462
 TTree.cxx:6463
 TTree.cxx:6464
 TTree.cxx:6465
 TTree.cxx:6466
 TTree.cxx:6467
 TTree.cxx:6468
 TTree.cxx:6469
 TTree.cxx:6470
 TTree.cxx:6471
 TTree.cxx:6472
 TTree.cxx:6473
 TTree.cxx:6474
 TTree.cxx:6475
 TTree.cxx:6476
 TTree.cxx:6477
 TTree.cxx:6478
 TTree.cxx:6479
 TTree.cxx:6480
 TTree.cxx:6481
 TTree.cxx:6482
 TTree.cxx:6483
 TTree.cxx:6484
 TTree.cxx:6485
 TTree.cxx:6486
 TTree.cxx:6487
 TTree.cxx:6488
 TTree.cxx:6489
 TTree.cxx:6490
 TTree.cxx:6491
 TTree.cxx:6492
 TTree.cxx:6493
 TTree.cxx:6494
 TTree.cxx:6495
 TTree.cxx:6496
 TTree.cxx:6497
 TTree.cxx:6498
 TTree.cxx:6499
 TTree.cxx:6500
 TTree.cxx:6501
 TTree.cxx:6502
 TTree.cxx:6503
 TTree.cxx:6504
 TTree.cxx:6505
 TTree.cxx:6506
 TTree.cxx:6507
 TTree.cxx:6508
 TTree.cxx:6509
 TTree.cxx:6510
 TTree.cxx:6511
 TTree.cxx:6512
 TTree.cxx:6513
 TTree.cxx:6514
 TTree.cxx:6515
 TTree.cxx:6516
 TTree.cxx:6517
 TTree.cxx:6518
 TTree.cxx:6519
 TTree.cxx:6520
 TTree.cxx:6521
 TTree.cxx:6522
 TTree.cxx:6523
 TTree.cxx:6524
 TTree.cxx:6525
 TTree.cxx:6526
 TTree.cxx:6527
 TTree.cxx:6528
 TTree.cxx:6529
 TTree.cxx:6530
 TTree.cxx:6531
 TTree.cxx:6532
 TTree.cxx:6533
 TTree.cxx:6534
 TTree.cxx:6535
 TTree.cxx:6536
 TTree.cxx:6537
 TTree.cxx:6538
 TTree.cxx:6539
 TTree.cxx:6540
 TTree.cxx:6541
 TTree.cxx:6542
 TTree.cxx:6543
 TTree.cxx:6544
 TTree.cxx:6545
 TTree.cxx:6546
 TTree.cxx:6547
 TTree.cxx:6548
 TTree.cxx:6549
 TTree.cxx:6550
 TTree.cxx:6551
 TTree.cxx:6552
 TTree.cxx:6553
 TTree.cxx:6554
 TTree.cxx:6555
 TTree.cxx:6556
 TTree.cxx:6557
 TTree.cxx:6558
 TTree.cxx:6559
 TTree.cxx:6560
 TTree.cxx:6561
 TTree.cxx:6562
 TTree.cxx:6563
 TTree.cxx:6564
 TTree.cxx:6565
 TTree.cxx:6566
 TTree.cxx:6567
 TTree.cxx:6568
 TTree.cxx:6569
 TTree.cxx:6570
 TTree.cxx:6571
 TTree.cxx:6572
 TTree.cxx:6573
 TTree.cxx:6574
 TTree.cxx:6575
 TTree.cxx:6576
 TTree.cxx:6577
 TTree.cxx:6578
 TTree.cxx:6579
 TTree.cxx:6580
 TTree.cxx:6581
 TTree.cxx:6582
 TTree.cxx:6583
 TTree.cxx:6584
 TTree.cxx:6585
 TTree.cxx:6586
 TTree.cxx:6587
 TTree.cxx:6588
 TTree.cxx:6589
 TTree.cxx:6590
 TTree.cxx:6591
 TTree.cxx:6592
 TTree.cxx:6593
 TTree.cxx:6594
 TTree.cxx:6595
 TTree.cxx:6596
 TTree.cxx:6597
 TTree.cxx:6598
 TTree.cxx:6599
 TTree.cxx:6600
 TTree.cxx:6601
 TTree.cxx:6602
 TTree.cxx:6603
 TTree.cxx:6604
 TTree.cxx:6605
 TTree.cxx:6606
 TTree.cxx:6607
 TTree.cxx:6608
 TTree.cxx:6609
 TTree.cxx:6610
 TTree.cxx:6611
 TTree.cxx:6612
 TTree.cxx:6613
 TTree.cxx:6614
 TTree.cxx:6615
 TTree.cxx:6616
 TTree.cxx:6617
 TTree.cxx:6618
 TTree.cxx:6619
 TTree.cxx:6620
 TTree.cxx:6621
 TTree.cxx:6622
 TTree.cxx:6623
 TTree.cxx:6624
 TTree.cxx:6625
 TTree.cxx:6626
 TTree.cxx:6627
 TTree.cxx:6628
 TTree.cxx:6629
 TTree.cxx:6630
 TTree.cxx:6631
 TTree.cxx:6632
 TTree.cxx:6633
 TTree.cxx:6634
 TTree.cxx:6635
 TTree.cxx:6636
 TTree.cxx:6637
 TTree.cxx:6638
 TTree.cxx:6639
 TTree.cxx:6640
 TTree.cxx:6641
 TTree.cxx:6642
 TTree.cxx:6643
 TTree.cxx:6644
 TTree.cxx:6645
 TTree.cxx:6646
 TTree.cxx:6647
 TTree.cxx:6648
 TTree.cxx:6649
 TTree.cxx:6650
 TTree.cxx:6651
 TTree.cxx:6652
 TTree.cxx:6653
 TTree.cxx:6654
 TTree.cxx:6655
 TTree.cxx:6656
 TTree.cxx:6657
 TTree.cxx:6658
 TTree.cxx:6659
 TTree.cxx:6660
 TTree.cxx:6661
 TTree.cxx:6662
 TTree.cxx:6663
 TTree.cxx:6664
 TTree.cxx:6665
 TTree.cxx:6666
 TTree.cxx:6667
 TTree.cxx:6668
 TTree.cxx:6669
 TTree.cxx:6670
 TTree.cxx:6671
 TTree.cxx:6672
 TTree.cxx:6673
 TTree.cxx:6674
 TTree.cxx:6675
 TTree.cxx:6676
 TTree.cxx:6677
 TTree.cxx:6678
 TTree.cxx:6679
 TTree.cxx:6680
 TTree.cxx:6681
 TTree.cxx:6682
 TTree.cxx:6683
 TTree.cxx:6684
 TTree.cxx:6685
 TTree.cxx:6686
 TTree.cxx:6687
 TTree.cxx:6688
 TTree.cxx:6689
 TTree.cxx:6690
 TTree.cxx:6691
 TTree.cxx:6692
 TTree.cxx:6693
 TTree.cxx:6694
 TTree.cxx:6695
 TTree.cxx:6696
 TTree.cxx:6697
 TTree.cxx:6698
 TTree.cxx:6699
 TTree.cxx:6700
 TTree.cxx:6701
 TTree.cxx:6702
 TTree.cxx:6703
 TTree.cxx:6704
 TTree.cxx:6705
 TTree.cxx:6706
 TTree.cxx:6707
 TTree.cxx:6708
 TTree.cxx:6709
 TTree.cxx:6710
 TTree.cxx:6711
 TTree.cxx:6712
 TTree.cxx:6713
 TTree.cxx:6714
 TTree.cxx:6715
 TTree.cxx:6716
 TTree.cxx:6717
 TTree.cxx:6718
 TTree.cxx:6719
 TTree.cxx:6720
 TTree.cxx:6721
 TTree.cxx:6722
 TTree.cxx:6723
 TTree.cxx:6724
 TTree.cxx:6725
 TTree.cxx:6726
 TTree.cxx:6727
 TTree.cxx:6728
 TTree.cxx:6729
 TTree.cxx:6730
 TTree.cxx:6731
 TTree.cxx:6732
 TTree.cxx:6733
 TTree.cxx:6734
 TTree.cxx:6735
 TTree.cxx:6736
 TTree.cxx:6737
 TTree.cxx:6738
 TTree.cxx:6739
 TTree.cxx:6740
 TTree.cxx:6741
 TTree.cxx:6742
 TTree.cxx:6743
 TTree.cxx:6744
 TTree.cxx:6745
 TTree.cxx:6746
 TTree.cxx:6747
 TTree.cxx:6748
 TTree.cxx:6749
 TTree.cxx:6750
 TTree.cxx:6751
 TTree.cxx:6752
 TTree.cxx:6753
 TTree.cxx:6754
 TTree.cxx:6755
 TTree.cxx:6756
 TTree.cxx:6757
 TTree.cxx:6758
 TTree.cxx:6759
 TTree.cxx:6760
 TTree.cxx:6761
 TTree.cxx:6762
 TTree.cxx:6763
 TTree.cxx:6764
 TTree.cxx:6765
 TTree.cxx:6766
 TTree.cxx:6767
 TTree.cxx:6768
 TTree.cxx:6769
 TTree.cxx:6770
 TTree.cxx:6771
 TTree.cxx:6772
 TTree.cxx:6773
 TTree.cxx:6774
 TTree.cxx:6775
 TTree.cxx:6776
 TTree.cxx:6777
 TTree.cxx:6778
 TTree.cxx:6779
 TTree.cxx:6780
 TTree.cxx:6781
 TTree.cxx:6782
 TTree.cxx:6783
 TTree.cxx:6784
 TTree.cxx:6785
 TTree.cxx:6786
 TTree.cxx:6787
 TTree.cxx:6788
 TTree.cxx:6789
 TTree.cxx:6790
 TTree.cxx:6791
 TTree.cxx:6792
 TTree.cxx:6793
 TTree.cxx:6794
 TTree.cxx:6795
 TTree.cxx:6796
 TTree.cxx:6797
 TTree.cxx:6798
 TTree.cxx:6799
 TTree.cxx:6800
 TTree.cxx:6801
 TTree.cxx:6802
 TTree.cxx:6803
 TTree.cxx:6804
 TTree.cxx:6805
 TTree.cxx:6806
 TTree.cxx:6807
 TTree.cxx:6808
 TTree.cxx:6809
 TTree.cxx:6810
 TTree.cxx:6811
 TTree.cxx:6812
 TTree.cxx:6813
 TTree.cxx:6814
 TTree.cxx:6815
 TTree.cxx:6816
 TTree.cxx:6817
 TTree.cxx:6818
 TTree.cxx:6819
 TTree.cxx:6820
 TTree.cxx:6821
 TTree.cxx:6822
 TTree.cxx:6823
 TTree.cxx:6824
 TTree.cxx:6825
 TTree.cxx:6826
 TTree.cxx:6827
 TTree.cxx:6828
 TTree.cxx:6829
 TTree.cxx:6830
 TTree.cxx:6831
 TTree.cxx:6832
 TTree.cxx:6833
 TTree.cxx:6834
 TTree.cxx:6835
 TTree.cxx:6836
 TTree.cxx:6837
 TTree.cxx:6838
 TTree.cxx:6839
 TTree.cxx:6840
 TTree.cxx:6841
 TTree.cxx:6842
 TTree.cxx:6843
 TTree.cxx:6844
 TTree.cxx:6845
 TTree.cxx:6846
 TTree.cxx:6847
 TTree.cxx:6848
 TTree.cxx:6849
 TTree.cxx:6850
 TTree.cxx:6851
 TTree.cxx:6852
 TTree.cxx:6853
 TTree.cxx:6854
 TTree.cxx:6855
 TTree.cxx:6856
 TTree.cxx:6857
 TTree.cxx:6858
 TTree.cxx:6859
 TTree.cxx:6860
 TTree.cxx:6861
 TTree.cxx:6862
 TTree.cxx:6863
 TTree.cxx:6864
 TTree.cxx:6865
 TTree.cxx:6866
 TTree.cxx:6867
 TTree.cxx:6868
 TTree.cxx:6869
 TTree.cxx:6870
 TTree.cxx:6871
 TTree.cxx:6872
 TTree.cxx:6873
 TTree.cxx:6874
 TTree.cxx:6875
 TTree.cxx:6876
 TTree.cxx:6877
 TTree.cxx:6878
 TTree.cxx:6879
 TTree.cxx:6880
 TTree.cxx:6881
 TTree.cxx:6882
 TTree.cxx:6883
 TTree.cxx:6884
 TTree.cxx:6885
 TTree.cxx:6886
 TTree.cxx:6887
 TTree.cxx:6888
 TTree.cxx:6889
 TTree.cxx:6890
 TTree.cxx:6891
 TTree.cxx:6892
 TTree.cxx:6893
 TTree.cxx:6894
 TTree.cxx:6895
 TTree.cxx:6896
 TTree.cxx:6897
 TTree.cxx:6898
 TTree.cxx:6899
 TTree.cxx:6900
 TTree.cxx:6901
 TTree.cxx:6902
 TTree.cxx:6903
 TTree.cxx:6904
 TTree.cxx:6905
 TTree.cxx:6906
 TTree.cxx:6907
 TTree.cxx:6908
 TTree.cxx:6909
 TTree.cxx:6910
 TTree.cxx:6911
 TTree.cxx:6912
 TTree.cxx:6913
 TTree.cxx:6914
 TTree.cxx:6915
 TTree.cxx:6916
 TTree.cxx:6917
 TTree.cxx:6918
 TTree.cxx:6919
 TTree.cxx:6920
 TTree.cxx:6921
 TTree.cxx:6922
 TTree.cxx:6923
 TTree.cxx:6924
 TTree.cxx:6925
 TTree.cxx:6926
 TTree.cxx:6927
 TTree.cxx:6928
 TTree.cxx:6929
 TTree.cxx:6930
 TTree.cxx:6931
 TTree.cxx:6932
 TTree.cxx:6933
 TTree.cxx:6934
 TTree.cxx:6935
 TTree.cxx:6936
 TTree.cxx:6937
 TTree.cxx:6938
 TTree.cxx:6939
 TTree.cxx:6940
 TTree.cxx:6941
 TTree.cxx:6942
 TTree.cxx:6943
 TTree.cxx:6944
 TTree.cxx:6945
 TTree.cxx:6946
 TTree.cxx:6947
 TTree.cxx:6948
 TTree.cxx:6949
 TTree.cxx:6950
 TTree.cxx:6951
 TTree.cxx:6952
 TTree.cxx:6953
 TTree.cxx:6954
 TTree.cxx:6955
 TTree.cxx:6956
 TTree.cxx:6957
 TTree.cxx:6958
 TTree.cxx:6959
 TTree.cxx:6960
 TTree.cxx:6961
 TTree.cxx:6962
 TTree.cxx:6963
 TTree.cxx:6964
 TTree.cxx:6965
 TTree.cxx:6966
 TTree.cxx:6967
 TTree.cxx:6968
 TTree.cxx:6969
 TTree.cxx:6970
 TTree.cxx:6971
 TTree.cxx:6972
 TTree.cxx:6973
 TTree.cxx:6974
 TTree.cxx:6975
 TTree.cxx:6976
 TTree.cxx:6977
 TTree.cxx:6978
 TTree.cxx:6979
 TTree.cxx:6980
 TTree.cxx:6981
 TTree.cxx:6982
 TTree.cxx:6983
 TTree.cxx:6984
 TTree.cxx:6985
 TTree.cxx:6986
 TTree.cxx:6987
 TTree.cxx:6988
 TTree.cxx:6989
 TTree.cxx:6990
 TTree.cxx:6991
 TTree.cxx:6992
 TTree.cxx:6993
 TTree.cxx:6994
 TTree.cxx:6995
 TTree.cxx:6996
 TTree.cxx:6997
 TTree.cxx:6998
 TTree.cxx:6999
 TTree.cxx:7000
 TTree.cxx:7001
 TTree.cxx:7002
 TTree.cxx:7003
 TTree.cxx:7004
 TTree.cxx:7005
 TTree.cxx:7006
 TTree.cxx:7007
 TTree.cxx:7008
 TTree.cxx:7009
 TTree.cxx:7010
 TTree.cxx:7011
 TTree.cxx:7012
 TTree.cxx:7013
 TTree.cxx:7014
 TTree.cxx:7015
 TTree.cxx:7016
 TTree.cxx:7017
 TTree.cxx:7018
 TTree.cxx:7019
 TTree.cxx:7020
 TTree.cxx:7021
 TTree.cxx:7022
 TTree.cxx:7023
 TTree.cxx:7024
 TTree.cxx:7025
 TTree.cxx:7026
 TTree.cxx:7027
 TTree.cxx:7028
 TTree.cxx:7029
 TTree.cxx:7030
 TTree.cxx:7031
 TTree.cxx:7032
 TTree.cxx:7033
 TTree.cxx:7034
 TTree.cxx:7035
 TTree.cxx:7036
 TTree.cxx:7037
 TTree.cxx:7038
 TTree.cxx:7039
 TTree.cxx:7040
 TTree.cxx:7041
 TTree.cxx:7042
 TTree.cxx:7043
 TTree.cxx:7044
 TTree.cxx:7045
 TTree.cxx:7046
 TTree.cxx:7047
 TTree.cxx:7048
 TTree.cxx:7049
 TTree.cxx:7050
 TTree.cxx:7051
 TTree.cxx:7052
 TTree.cxx:7053
 TTree.cxx:7054
 TTree.cxx:7055
 TTree.cxx:7056
 TTree.cxx:7057
 TTree.cxx:7058
 TTree.cxx:7059
 TTree.cxx:7060
 TTree.cxx:7061
 TTree.cxx:7062
 TTree.cxx:7063
 TTree.cxx:7064
 TTree.cxx:7065
 TTree.cxx:7066
 TTree.cxx:7067
 TTree.cxx:7068
 TTree.cxx:7069
 TTree.cxx:7070
 TTree.cxx:7071
 TTree.cxx:7072
 TTree.cxx:7073
 TTree.cxx:7074
 TTree.cxx:7075
 TTree.cxx:7076
 TTree.cxx:7077
 TTree.cxx:7078
 TTree.cxx:7079
 TTree.cxx:7080
 TTree.cxx:7081
 TTree.cxx:7082
 TTree.cxx:7083
 TTree.cxx:7084
 TTree.cxx:7085
 TTree.cxx:7086
 TTree.cxx:7087
 TTree.cxx:7088
 TTree.cxx:7089
 TTree.cxx:7090
 TTree.cxx:7091
 TTree.cxx:7092
 TTree.cxx:7093
 TTree.cxx:7094
 TTree.cxx:7095
 TTree.cxx:7096
 TTree.cxx:7097
 TTree.cxx:7098
 TTree.cxx:7099
 TTree.cxx:7100
 TTree.cxx:7101
 TTree.cxx:7102
 TTree.cxx:7103
 TTree.cxx:7104
 TTree.cxx:7105
 TTree.cxx:7106
 TTree.cxx:7107
 TTree.cxx:7108
 TTree.cxx:7109
 TTree.cxx:7110
 TTree.cxx:7111
 TTree.cxx:7112
 TTree.cxx:7113
 TTree.cxx:7114
 TTree.cxx:7115
 TTree.cxx:7116
 TTree.cxx:7117
 TTree.cxx:7118
 TTree.cxx:7119
 TTree.cxx:7120
 TTree.cxx:7121
 TTree.cxx:7122
 TTree.cxx:7123
 TTree.cxx:7124
 TTree.cxx:7125
 TTree.cxx:7126
 TTree.cxx:7127
 TTree.cxx:7128
 TTree.cxx:7129
 TTree.cxx:7130
 TTree.cxx:7131
 TTree.cxx:7132
 TTree.cxx:7133
 TTree.cxx:7134
 TTree.cxx:7135
 TTree.cxx:7136
 TTree.cxx:7137
 TTree.cxx:7138
 TTree.cxx:7139
 TTree.cxx:7140
 TTree.cxx:7141
 TTree.cxx:7142
 TTree.cxx:7143
 TTree.cxx:7144
 TTree.cxx:7145
 TTree.cxx:7146
 TTree.cxx:7147
 TTree.cxx:7148
 TTree.cxx:7149
 TTree.cxx:7150
 TTree.cxx:7151
 TTree.cxx:7152
 TTree.cxx:7153
 TTree.cxx:7154
 TTree.cxx:7155
 TTree.cxx:7156
 TTree.cxx:7157
 TTree.cxx:7158
 TTree.cxx:7159
 TTree.cxx:7160
 TTree.cxx:7161
 TTree.cxx:7162
 TTree.cxx:7163
 TTree.cxx:7164
 TTree.cxx:7165
 TTree.cxx:7166
 TTree.cxx:7167
 TTree.cxx:7168
 TTree.cxx:7169
 TTree.cxx:7170
 TTree.cxx:7171
 TTree.cxx:7172
 TTree.cxx:7173
 TTree.cxx:7174
 TTree.cxx:7175
 TTree.cxx:7176
 TTree.cxx:7177
 TTree.cxx:7178
 TTree.cxx:7179
 TTree.cxx:7180
 TTree.cxx:7181
 TTree.cxx:7182
 TTree.cxx:7183
 TTree.cxx:7184
 TTree.cxx:7185
 TTree.cxx:7186
 TTree.cxx:7187
 TTree.cxx:7188
 TTree.cxx:7189
 TTree.cxx:7190
 TTree.cxx:7191
 TTree.cxx:7192
 TTree.cxx:7193
 TTree.cxx:7194
 TTree.cxx:7195
 TTree.cxx:7196
 TTree.cxx:7197
 TTree.cxx:7198
 TTree.cxx:7199
 TTree.cxx:7200
 TTree.cxx:7201
 TTree.cxx:7202
 TTree.cxx:7203
 TTree.cxx:7204
 TTree.cxx:7205
 TTree.cxx:7206
 TTree.cxx:7207
 TTree.cxx:7208
 TTree.cxx:7209
 TTree.cxx:7210
 TTree.cxx:7211
 TTree.cxx:7212
 TTree.cxx:7213
 TTree.cxx:7214
 TTree.cxx:7215
 TTree.cxx:7216
 TTree.cxx:7217
 TTree.cxx:7218
 TTree.cxx:7219
 TTree.cxx:7220
 TTree.cxx:7221
 TTree.cxx:7222
 TTree.cxx:7223
 TTree.cxx:7224
 TTree.cxx:7225
 TTree.cxx:7226
 TTree.cxx:7227
 TTree.cxx:7228
 TTree.cxx:7229
 TTree.cxx:7230
 TTree.cxx:7231
 TTree.cxx:7232
 TTree.cxx:7233
 TTree.cxx:7234
 TTree.cxx:7235
 TTree.cxx:7236
 TTree.cxx:7237
 TTree.cxx:7238
 TTree.cxx:7239
 TTree.cxx:7240
 TTree.cxx:7241
 TTree.cxx:7242
 TTree.cxx:7243
 TTree.cxx:7244
 TTree.cxx:7245
 TTree.cxx:7246
 TTree.cxx:7247
 TTree.cxx:7248
 TTree.cxx:7249
 TTree.cxx:7250
 TTree.cxx:7251
 TTree.cxx:7252
 TTree.cxx:7253
 TTree.cxx:7254
 TTree.cxx:7255
 TTree.cxx:7256
 TTree.cxx:7257
 TTree.cxx:7258
 TTree.cxx:7259
 TTree.cxx:7260
 TTree.cxx:7261
 TTree.cxx:7262
 TTree.cxx:7263
 TTree.cxx:7264
 TTree.cxx:7265
 TTree.cxx:7266
 TTree.cxx:7267
 TTree.cxx:7268
 TTree.cxx:7269
 TTree.cxx:7270
 TTree.cxx:7271
 TTree.cxx:7272
 TTree.cxx:7273
 TTree.cxx:7274
 TTree.cxx:7275
 TTree.cxx:7276
 TTree.cxx:7277
 TTree.cxx:7278
 TTree.cxx:7279
 TTree.cxx:7280
 TTree.cxx:7281
 TTree.cxx:7282
 TTree.cxx:7283
 TTree.cxx:7284
 TTree.cxx:7285
 TTree.cxx:7286
 TTree.cxx:7287
 TTree.cxx:7288
 TTree.cxx:7289
 TTree.cxx:7290
 TTree.cxx:7291
 TTree.cxx:7292
 TTree.cxx:7293
 TTree.cxx:7294
 TTree.cxx:7295
 TTree.cxx:7296
 TTree.cxx:7297
 TTree.cxx:7298
 TTree.cxx:7299
 TTree.cxx:7300
 TTree.cxx:7301
 TTree.cxx:7302
 TTree.cxx:7303
 TTree.cxx:7304
 TTree.cxx:7305
 TTree.cxx:7306
 TTree.cxx:7307
 TTree.cxx:7308
 TTree.cxx:7309
 TTree.cxx:7310
 TTree.cxx:7311
 TTree.cxx:7312
 TTree.cxx:7313
 TTree.cxx:7314
 TTree.cxx:7315
 TTree.cxx:7316
 TTree.cxx:7317
 TTree.cxx:7318
 TTree.cxx:7319
 TTree.cxx:7320
 TTree.cxx:7321
 TTree.cxx:7322
 TTree.cxx:7323
 TTree.cxx:7324
 TTree.cxx:7325
 TTree.cxx:7326
 TTree.cxx:7327
 TTree.cxx:7328
 TTree.cxx:7329
 TTree.cxx:7330
 TTree.cxx:7331
 TTree.cxx:7332
 TTree.cxx:7333
 TTree.cxx:7334
 TTree.cxx:7335
 TTree.cxx:7336
 TTree.cxx:7337
 TTree.cxx:7338
 TTree.cxx:7339
 TTree.cxx:7340
 TTree.cxx:7341
 TTree.cxx:7342
 TTree.cxx:7343
 TTree.cxx:7344
 TTree.cxx:7345
 TTree.cxx:7346
 TTree.cxx:7347
 TTree.cxx:7348
 TTree.cxx:7349
 TTree.cxx:7350
 TTree.cxx:7351
 TTree.cxx:7352
 TTree.cxx:7353
 TTree.cxx:7354
 TTree.cxx:7355
 TTree.cxx:7356
 TTree.cxx:7357
 TTree.cxx:7358
 TTree.cxx:7359
 TTree.cxx:7360
 TTree.cxx:7361
 TTree.cxx:7362
 TTree.cxx:7363
 TTree.cxx:7364
 TTree.cxx:7365
 TTree.cxx:7366
 TTree.cxx:7367
 TTree.cxx:7368
 TTree.cxx:7369
 TTree.cxx:7370
 TTree.cxx:7371
 TTree.cxx:7372
 TTree.cxx:7373
 TTree.cxx:7374
 TTree.cxx:7375
 TTree.cxx:7376
 TTree.cxx:7377
 TTree.cxx:7378
 TTree.cxx:7379
 TTree.cxx:7380
 TTree.cxx:7381
 TTree.cxx:7382
 TTree.cxx:7383
 TTree.cxx:7384
 TTree.cxx:7385
 TTree.cxx:7386
 TTree.cxx:7387
 TTree.cxx:7388
 TTree.cxx:7389
 TTree.cxx:7390
 TTree.cxx:7391
 TTree.cxx:7392
 TTree.cxx:7393
 TTree.cxx:7394
 TTree.cxx:7395
 TTree.cxx:7396
 TTree.cxx:7397
 TTree.cxx:7398
 TTree.cxx:7399
 TTree.cxx:7400
 TTree.cxx:7401
 TTree.cxx:7402
 TTree.cxx:7403
 TTree.cxx:7404
 TTree.cxx:7405
 TTree.cxx:7406
 TTree.cxx:7407
 TTree.cxx:7408
 TTree.cxx:7409
 TTree.cxx:7410
 TTree.cxx:7411
 TTree.cxx:7412
 TTree.cxx:7413
 TTree.cxx:7414
 TTree.cxx:7415
 TTree.cxx:7416
 TTree.cxx:7417
 TTree.cxx:7418
 TTree.cxx:7419
 TTree.cxx:7420
 TTree.cxx:7421
 TTree.cxx:7422
 TTree.cxx:7423
 TTree.cxx:7424
 TTree.cxx:7425
 TTree.cxx:7426
 TTree.cxx:7427
 TTree.cxx:7428
 TTree.cxx:7429
 TTree.cxx:7430
 TTree.cxx:7431
 TTree.cxx:7432
 TTree.cxx:7433
 TTree.cxx:7434
 TTree.cxx:7435
 TTree.cxx:7436
 TTree.cxx:7437
 TTree.cxx:7438
 TTree.cxx:7439
 TTree.cxx:7440
 TTree.cxx:7441
 TTree.cxx:7442
 TTree.cxx:7443
 TTree.cxx:7444
 TTree.cxx:7445
 TTree.cxx:7446
 TTree.cxx:7447
 TTree.cxx:7448
 TTree.cxx:7449
 TTree.cxx:7450
 TTree.cxx:7451
 TTree.cxx:7452
 TTree.cxx:7453
 TTree.cxx:7454
 TTree.cxx:7455
 TTree.cxx:7456
 TTree.cxx:7457
 TTree.cxx:7458
 TTree.cxx:7459
 TTree.cxx:7460
 TTree.cxx:7461
 TTree.cxx:7462
 TTree.cxx:7463
 TTree.cxx:7464
 TTree.cxx:7465
 TTree.cxx:7466
 TTree.cxx:7467
 TTree.cxx:7468
 TTree.cxx:7469
 TTree.cxx:7470
 TTree.cxx:7471
 TTree.cxx:7472
 TTree.cxx:7473
 TTree.cxx:7474
 TTree.cxx:7475
 TTree.cxx:7476
 TTree.cxx:7477
 TTree.cxx:7478
 TTree.cxx:7479
 TTree.cxx:7480
 TTree.cxx:7481
 TTree.cxx:7482
 TTree.cxx:7483
 TTree.cxx:7484
 TTree.cxx:7485
 TTree.cxx:7486
 TTree.cxx:7487
 TTree.cxx:7488
 TTree.cxx:7489
 TTree.cxx:7490
 TTree.cxx:7491
 TTree.cxx:7492
 TTree.cxx:7493
 TTree.cxx:7494
 TTree.cxx:7495
 TTree.cxx:7496
 TTree.cxx:7497
 TTree.cxx:7498
 TTree.cxx:7499
 TTree.cxx:7500
 TTree.cxx:7501
 TTree.cxx:7502
 TTree.cxx:7503
 TTree.cxx:7504
 TTree.cxx:7505
 TTree.cxx:7506
 TTree.cxx:7507
 TTree.cxx:7508
 TTree.cxx:7509
 TTree.cxx:7510
 TTree.cxx:7511
 TTree.cxx:7512
 TTree.cxx:7513
 TTree.cxx:7514
 TTree.cxx:7515
 TTree.cxx:7516
 TTree.cxx:7517
 TTree.cxx:7518
 TTree.cxx:7519
 TTree.cxx:7520
 TTree.cxx:7521
 TTree.cxx:7522
 TTree.cxx:7523
 TTree.cxx:7524
 TTree.cxx:7525
 TTree.cxx:7526
 TTree.cxx:7527
 TTree.cxx:7528
 TTree.cxx:7529
 TTree.cxx:7530
 TTree.cxx:7531
 TTree.cxx:7532
 TTree.cxx:7533
 TTree.cxx:7534
 TTree.cxx:7535
 TTree.cxx:7536
 TTree.cxx:7537
 TTree.cxx:7538
 TTree.cxx:7539
 TTree.cxx:7540
 TTree.cxx:7541
 TTree.cxx:7542
 TTree.cxx:7543
 TTree.cxx:7544
 TTree.cxx:7545
 TTree.cxx:7546
 TTree.cxx:7547
 TTree.cxx:7548
 TTree.cxx:7549
 TTree.cxx:7550
 TTree.cxx:7551
 TTree.cxx:7552
 TTree.cxx:7553
 TTree.cxx:7554
 TTree.cxx:7555
 TTree.cxx:7556
 TTree.cxx:7557
 TTree.cxx:7558
 TTree.cxx:7559
 TTree.cxx:7560
 TTree.cxx:7561
 TTree.cxx:7562
 TTree.cxx:7563
 TTree.cxx:7564
 TTree.cxx:7565
 TTree.cxx:7566
 TTree.cxx:7567
 TTree.cxx:7568
 TTree.cxx:7569
 TTree.cxx:7570
 TTree.cxx:7571
 TTree.cxx:7572
 TTree.cxx:7573
 TTree.cxx:7574
 TTree.cxx:7575
 TTree.cxx:7576
 TTree.cxx:7577
 TTree.cxx:7578
 TTree.cxx:7579
 TTree.cxx:7580
 TTree.cxx:7581
 TTree.cxx:7582
 TTree.cxx:7583
 TTree.cxx:7584
 TTree.cxx:7585
 TTree.cxx:7586
 TTree.cxx:7587
 TTree.cxx:7588
 TTree.cxx:7589
 TTree.cxx:7590
 TTree.cxx:7591
 TTree.cxx:7592
 TTree.cxx:7593
 TTree.cxx:7594
 TTree.cxx:7595
 TTree.cxx:7596
 TTree.cxx:7597
 TTree.cxx:7598
 TTree.cxx:7599
 TTree.cxx:7600
 TTree.cxx:7601
 TTree.cxx:7602
 TTree.cxx:7603
 TTree.cxx:7604
 TTree.cxx:7605
 TTree.cxx:7606
 TTree.cxx:7607
 TTree.cxx:7608
 TTree.cxx:7609
 TTree.cxx:7610
 TTree.cxx:7611
 TTree.cxx:7612
 TTree.cxx:7613
 TTree.cxx:7614
 TTree.cxx:7615
 TTree.cxx:7616
 TTree.cxx:7617
 TTree.cxx:7618
 TTree.cxx:7619
 TTree.cxx:7620
 TTree.cxx:7621
 TTree.cxx:7622
 TTree.cxx:7623
 TTree.cxx:7624
 TTree.cxx:7625
 TTree.cxx:7626
 TTree.cxx:7627
 TTree.cxx:7628
 TTree.cxx:7629
 TTree.cxx:7630
 TTree.cxx:7631
 TTree.cxx:7632
 TTree.cxx:7633
 TTree.cxx:7634
 TTree.cxx:7635
 TTree.cxx:7636
 TTree.cxx:7637
 TTree.cxx:7638
 TTree.cxx:7639
 TTree.cxx:7640
 TTree.cxx:7641
 TTree.cxx:7642
 TTree.cxx:7643
 TTree.cxx:7644
 TTree.cxx:7645
 TTree.cxx:7646
 TTree.cxx:7647
 TTree.cxx:7648
 TTree.cxx:7649
 TTree.cxx:7650
 TTree.cxx:7651
 TTree.cxx:7652
 TTree.cxx:7653
 TTree.cxx:7654
 TTree.cxx:7655
 TTree.cxx:7656
 TTree.cxx:7657
 TTree.cxx:7658
 TTree.cxx:7659
 TTree.cxx:7660
 TTree.cxx:7661
 TTree.cxx:7662
 TTree.cxx:7663
 TTree.cxx:7664
 TTree.cxx:7665
 TTree.cxx:7666
 TTree.cxx:7667
 TTree.cxx:7668
 TTree.cxx:7669
 TTree.cxx:7670
 TTree.cxx:7671
 TTree.cxx:7672
 TTree.cxx:7673
 TTree.cxx:7674
 TTree.cxx:7675
 TTree.cxx:7676
 TTree.cxx:7677
 TTree.cxx:7678
 TTree.cxx:7679
 TTree.cxx:7680
 TTree.cxx:7681
 TTree.cxx:7682
 TTree.cxx:7683
 TTree.cxx:7684
 TTree.cxx:7685
 TTree.cxx:7686
 TTree.cxx:7687
 TTree.cxx:7688
 TTree.cxx:7689
 TTree.cxx:7690
 TTree.cxx:7691
 TTree.cxx:7692
 TTree.cxx:7693
 TTree.cxx:7694
 TTree.cxx:7695
 TTree.cxx:7696
 TTree.cxx:7697
 TTree.cxx:7698
 TTree.cxx:7699
 TTree.cxx:7700
 TTree.cxx:7701
 TTree.cxx:7702
 TTree.cxx:7703
 TTree.cxx:7704
 TTree.cxx:7705
 TTree.cxx:7706
 TTree.cxx:7707
 TTree.cxx:7708
 TTree.cxx:7709
 TTree.cxx:7710
 TTree.cxx:7711
 TTree.cxx:7712
 TTree.cxx:7713
 TTree.cxx:7714
 TTree.cxx:7715
 TTree.cxx:7716
 TTree.cxx:7717
 TTree.cxx:7718
 TTree.cxx:7719
 TTree.cxx:7720
 TTree.cxx:7721
 TTree.cxx:7722
 TTree.cxx:7723
 TTree.cxx:7724
 TTree.cxx:7725
 TTree.cxx:7726
 TTree.cxx:7727
 TTree.cxx:7728
 TTree.cxx:7729
 TTree.cxx:7730
 TTree.cxx:7731
 TTree.cxx:7732
 TTree.cxx:7733
 TTree.cxx:7734
 TTree.cxx:7735
 TTree.cxx:7736
 TTree.cxx:7737
 TTree.cxx:7738
 TTree.cxx:7739
 TTree.cxx:7740
 TTree.cxx:7741
 TTree.cxx:7742
 TTree.cxx:7743
 TTree.cxx:7744
 TTree.cxx:7745
 TTree.cxx:7746
 TTree.cxx:7747
 TTree.cxx:7748
 TTree.cxx:7749
 TTree.cxx:7750
 TTree.cxx:7751
 TTree.cxx:7752
 TTree.cxx:7753
 TTree.cxx:7754
 TTree.cxx:7755
 TTree.cxx:7756
 TTree.cxx:7757
 TTree.cxx:7758
 TTree.cxx:7759
 TTree.cxx:7760
 TTree.cxx:7761
 TTree.cxx:7762
 TTree.cxx:7763
 TTree.cxx:7764
 TTree.cxx:7765
 TTree.cxx:7766
 TTree.cxx:7767
 TTree.cxx:7768
 TTree.cxx:7769
 TTree.cxx:7770
 TTree.cxx:7771
 TTree.cxx:7772
 TTree.cxx:7773
 TTree.cxx:7774
 TTree.cxx:7775
 TTree.cxx:7776
 TTree.cxx:7777
 TTree.cxx:7778
 TTree.cxx:7779
 TTree.cxx:7780
 TTree.cxx:7781
 TTree.cxx:7782
 TTree.cxx:7783
 TTree.cxx:7784
 TTree.cxx:7785
 TTree.cxx:7786
 TTree.cxx:7787
 TTree.cxx:7788
 TTree.cxx:7789
 TTree.cxx:7790
 TTree.cxx:7791
 TTree.cxx:7792
 TTree.cxx:7793
 TTree.cxx:7794
 TTree.cxx:7795
 TTree.cxx:7796
 TTree.cxx:7797
 TTree.cxx:7798
 TTree.cxx:7799
 TTree.cxx:7800
 TTree.cxx:7801
 TTree.cxx:7802
 TTree.cxx:7803
 TTree.cxx:7804
 TTree.cxx:7805
 TTree.cxx:7806
 TTree.cxx:7807
 TTree.cxx:7808
 TTree.cxx:7809
 TTree.cxx:7810
 TTree.cxx:7811
 TTree.cxx:7812
 TTree.cxx:7813
 TTree.cxx:7814
 TTree.cxx:7815
 TTree.cxx:7816
 TTree.cxx:7817
 TTree.cxx:7818
 TTree.cxx:7819
 TTree.cxx:7820
 TTree.cxx:7821
 TTree.cxx:7822
 TTree.cxx:7823
 TTree.cxx:7824
 TTree.cxx:7825
 TTree.cxx:7826
 TTree.cxx:7827
 TTree.cxx:7828
 TTree.cxx:7829
 TTree.cxx:7830
 TTree.cxx:7831
 TTree.cxx:7832
 TTree.cxx:7833
 TTree.cxx:7834
 TTree.cxx:7835
 TTree.cxx:7836
 TTree.cxx:7837
 TTree.cxx:7838
 TTree.cxx:7839
 TTree.cxx:7840
 TTree.cxx:7841
 TTree.cxx:7842
 TTree.cxx:7843
 TTree.cxx:7844
 TTree.cxx:7845
 TTree.cxx:7846
 TTree.cxx:7847
 TTree.cxx:7848
 TTree.cxx:7849
 TTree.cxx:7850
 TTree.cxx:7851
 TTree.cxx:7852
 TTree.cxx:7853
 TTree.cxx:7854
 TTree.cxx:7855
 TTree.cxx:7856
 TTree.cxx:7857
 TTree.cxx:7858
 TTree.cxx:7859
 TTree.cxx:7860
 TTree.cxx:7861
 TTree.cxx:7862
 TTree.cxx:7863
 TTree.cxx:7864
 TTree.cxx:7865
 TTree.cxx:7866
 TTree.cxx:7867
 TTree.cxx:7868
 TTree.cxx:7869
 TTree.cxx:7870
 TTree.cxx:7871
 TTree.cxx:7872
 TTree.cxx:7873
 TTree.cxx:7874
 TTree.cxx:7875
 TTree.cxx:7876
 TTree.cxx:7877
 TTree.cxx:7878
 TTree.cxx:7879
 TTree.cxx:7880
 TTree.cxx:7881
 TTree.cxx:7882
 TTree.cxx:7883
 TTree.cxx:7884
 TTree.cxx:7885
 TTree.cxx:7886
 TTree.cxx:7887
 TTree.cxx:7888
 TTree.cxx:7889
 TTree.cxx:7890
 TTree.cxx:7891
 TTree.cxx:7892
 TTree.cxx:7893
 TTree.cxx:7894
 TTree.cxx:7895
 TTree.cxx:7896
 TTree.cxx:7897
 TTree.cxx:7898
 TTree.cxx:7899
 TTree.cxx:7900
 TTree.cxx:7901
 TTree.cxx:7902
 TTree.cxx:7903
 TTree.cxx:7904
 TTree.cxx:7905
 TTree.cxx:7906
 TTree.cxx:7907
 TTree.cxx:7908
 TTree.cxx:7909
 TTree.cxx:7910
 TTree.cxx:7911
 TTree.cxx:7912
 TTree.cxx:7913
 TTree.cxx:7914
 TTree.cxx:7915
 TTree.cxx:7916
 TTree.cxx:7917
 TTree.cxx:7918
 TTree.cxx:7919
 TTree.cxx:7920
 TTree.cxx:7921
 TTree.cxx:7922
 TTree.cxx:7923
 TTree.cxx:7924
 TTree.cxx:7925
 TTree.cxx:7926
 TTree.cxx:7927
 TTree.cxx:7928
 TTree.cxx:7929
 TTree.cxx:7930
 TTree.cxx:7931
 TTree.cxx:7932
 TTree.cxx:7933
 TTree.cxx:7934
 TTree.cxx:7935
 TTree.cxx:7936
 TTree.cxx:7937
 TTree.cxx:7938
 TTree.cxx:7939
 TTree.cxx:7940
 TTree.cxx:7941
 TTree.cxx:7942
 TTree.cxx:7943
 TTree.cxx:7944
 TTree.cxx:7945
 TTree.cxx:7946
 TTree.cxx:7947
 TTree.cxx:7948
 TTree.cxx:7949
 TTree.cxx:7950
 TTree.cxx:7951
 TTree.cxx:7952
 TTree.cxx:7953
 TTree.cxx:7954
 TTree.cxx:7955
 TTree.cxx:7956
 TTree.cxx:7957
 TTree.cxx:7958
 TTree.cxx:7959
 TTree.cxx:7960
 TTree.cxx:7961
 TTree.cxx:7962
 TTree.cxx:7963
 TTree.cxx:7964
 TTree.cxx:7965
 TTree.cxx:7966
 TTree.cxx:7967
 TTree.cxx:7968
 TTree.cxx:7969
 TTree.cxx:7970
 TTree.cxx:7971
 TTree.cxx:7972
 TTree.cxx:7973
 TTree.cxx:7974
 TTree.cxx:7975
 TTree.cxx:7976
 TTree.cxx:7977
 TTree.cxx:7978
 TTree.cxx:7979
 TTree.cxx:7980
 TTree.cxx:7981
 TTree.cxx:7982
 TTree.cxx:7983
 TTree.cxx:7984
 TTree.cxx:7985
 TTree.cxx:7986
 TTree.cxx:7987
 TTree.cxx:7988
 TTree.cxx:7989
 TTree.cxx:7990
 TTree.cxx:7991
 TTree.cxx:7992
 TTree.cxx:7993
 TTree.cxx:7994
 TTree.cxx:7995
 TTree.cxx:7996
 TTree.cxx:7997
 TTree.cxx:7998
 TTree.cxx:7999
 TTree.cxx:8000
 TTree.cxx:8001
 TTree.cxx:8002
 TTree.cxx:8003
 TTree.cxx:8004
 TTree.cxx:8005
 TTree.cxx:8006
 TTree.cxx:8007
 TTree.cxx:8008
 TTree.cxx:8009
 TTree.cxx:8010
 TTree.cxx:8011
 TTree.cxx:8012
 TTree.cxx:8013
 TTree.cxx:8014
 TTree.cxx:8015
 TTree.cxx:8016
 TTree.cxx:8017
 TTree.cxx:8018
 TTree.cxx:8019
 TTree.cxx:8020
 TTree.cxx:8021
 TTree.cxx:8022
 TTree.cxx:8023
 TTree.cxx:8024
 TTree.cxx:8025
 TTree.cxx:8026
 TTree.cxx:8027
 TTree.cxx:8028
 TTree.cxx:8029
 TTree.cxx:8030
 TTree.cxx:8031
 TTree.cxx:8032
 TTree.cxx:8033
 TTree.cxx:8034
 TTree.cxx:8035
 TTree.cxx:8036
 TTree.cxx:8037
 TTree.cxx:8038
 TTree.cxx:8039
 TTree.cxx:8040
 TTree.cxx:8041
 TTree.cxx:8042
 TTree.cxx:8043
 TTree.cxx:8044
 TTree.cxx:8045
 TTree.cxx:8046
 TTree.cxx:8047
 TTree.cxx:8048
 TTree.cxx:8049
 TTree.cxx:8050
 TTree.cxx:8051
 TTree.cxx:8052
 TTree.cxx:8053
 TTree.cxx:8054
 TTree.cxx:8055
 TTree.cxx:8056
 TTree.cxx:8057
 TTree.cxx:8058
 TTree.cxx:8059
 TTree.cxx:8060
 TTree.cxx:8061
 TTree.cxx:8062
 TTree.cxx:8063
 TTree.cxx:8064
 TTree.cxx:8065
 TTree.cxx:8066
 TTree.cxx:8067
 TTree.cxx:8068
 TTree.cxx:8069
 TTree.cxx:8070
 TTree.cxx:8071
 TTree.cxx:8072
 TTree.cxx:8073
 TTree.cxx:8074
 TTree.cxx:8075
 TTree.cxx:8076
 TTree.cxx:8077
 TTree.cxx:8078
 TTree.cxx:8079
 TTree.cxx:8080
 TTree.cxx:8081
 TTree.cxx:8082
 TTree.cxx:8083
 TTree.cxx:8084
 TTree.cxx:8085
 TTree.cxx:8086
 TTree.cxx:8087
 TTree.cxx:8088
 TTree.cxx:8089
 TTree.cxx:8090
 TTree.cxx:8091
 TTree.cxx:8092
 TTree.cxx:8093
 TTree.cxx:8094
 TTree.cxx:8095
 TTree.cxx:8096
 TTree.cxx:8097
 TTree.cxx:8098
 TTree.cxx:8099
 TTree.cxx:8100
 TTree.cxx:8101
 TTree.cxx:8102
 TTree.cxx:8103
 TTree.cxx:8104
 TTree.cxx:8105
 TTree.cxx:8106
 TTree.cxx:8107
 TTree.cxx:8108
 TTree.cxx:8109
 TTree.cxx:8110
 TTree.cxx:8111
 TTree.cxx:8112
 TTree.cxx:8113
 TTree.cxx:8114
 TTree.cxx:8115
 TTree.cxx:8116
 TTree.cxx:8117
 TTree.cxx:8118
 TTree.cxx:8119
 TTree.cxx:8120
 TTree.cxx:8121
 TTree.cxx:8122
 TTree.cxx:8123
 TTree.cxx:8124
 TTree.cxx:8125
 TTree.cxx:8126
 TTree.cxx:8127
 TTree.cxx:8128
 TTree.cxx:8129
 TTree.cxx:8130
 TTree.cxx:8131
 TTree.cxx:8132
 TTree.cxx:8133
 TTree.cxx:8134
 TTree.cxx:8135
 TTree.cxx:8136
 TTree.cxx:8137
 TTree.cxx:8138
 TTree.cxx:8139
 TTree.cxx:8140
 TTree.cxx:8141
 TTree.cxx:8142
 TTree.cxx:8143
 TTree.cxx:8144
 TTree.cxx:8145
 TTree.cxx:8146
 TTree.cxx:8147
 TTree.cxx:8148
 TTree.cxx:8149
 TTree.cxx:8150
 TTree.cxx:8151
 TTree.cxx:8152
 TTree.cxx:8153
 TTree.cxx:8154
 TTree.cxx:8155
 TTree.cxx:8156
 TTree.cxx:8157
 TTree.cxx:8158
 TTree.cxx:8159
 TTree.cxx:8160
 TTree.cxx:8161
 TTree.cxx:8162
 TTree.cxx:8163
 TTree.cxx:8164
 TTree.cxx:8165
 TTree.cxx:8166
 TTree.cxx:8167
 TTree.cxx:8168
 TTree.cxx:8169
 TTree.cxx:8170
 TTree.cxx:8171
 TTree.cxx:8172
 TTree.cxx:8173
 TTree.cxx:8174
 TTree.cxx:8175
 TTree.cxx:8176
 TTree.cxx:8177
 TTree.cxx:8178
 TTree.cxx:8179
 TTree.cxx:8180
 TTree.cxx:8181
 TTree.cxx:8182
 TTree.cxx:8183
 TTree.cxx:8184
 TTree.cxx:8185
 TTree.cxx:8186
 TTree.cxx:8187
 TTree.cxx:8188
 TTree.cxx:8189
 TTree.cxx:8190
 TTree.cxx:8191
 TTree.cxx:8192
 TTree.cxx:8193
 TTree.cxx:8194
 TTree.cxx:8195
 TTree.cxx:8196
 TTree.cxx:8197
 TTree.cxx:8198
 TTree.cxx:8199
 TTree.cxx:8200
 TTree.cxx:8201
 TTree.cxx:8202
 TTree.cxx:8203
 TTree.cxx:8204
 TTree.cxx:8205
 TTree.cxx:8206
 TTree.cxx:8207
 TTree.cxx:8208
 TTree.cxx:8209
 TTree.cxx:8210
 TTree.cxx:8211
 TTree.cxx:8212
 TTree.cxx:8213
 TTree.cxx:8214
 TTree.cxx:8215
 TTree.cxx:8216
 TTree.cxx:8217
 TTree.cxx:8218
 TTree.cxx:8219
 TTree.cxx:8220
 TTree.cxx:8221
 TTree.cxx:8222
 TTree.cxx:8223
 TTree.cxx:8224
 TTree.cxx:8225
 TTree.cxx:8226
 TTree.cxx:8227
 TTree.cxx:8228
 TTree.cxx:8229
 TTree.cxx:8230
 TTree.cxx:8231
 TTree.cxx:8232
 TTree.cxx:8233
 TTree.cxx:8234
 TTree.cxx:8235
 TTree.cxx:8236
 TTree.cxx:8237
 TTree.cxx:8238
 TTree.cxx:8239
 TTree.cxx:8240
 TTree.cxx:8241
 TTree.cxx:8242
 TTree.cxx:8243
 TTree.cxx:8244
 TTree.cxx:8245
 TTree.cxx:8246
 TTree.cxx:8247
 TTree.cxx:8248
 TTree.cxx:8249
 TTree.cxx:8250
 TTree.cxx:8251
 TTree.cxx:8252
 TTree.cxx:8253
 TTree.cxx:8254
 TTree.cxx:8255
 TTree.cxx:8256
 TTree.cxx:8257
 TTree.cxx:8258
 TTree.cxx:8259
 TTree.cxx:8260
 TTree.cxx:8261
 TTree.cxx:8262
 TTree.cxx:8263
 TTree.cxx:8264
 TTree.cxx:8265
 TTree.cxx:8266
 TTree.cxx:8267
 TTree.cxx:8268
 TTree.cxx:8269
 TTree.cxx:8270
 TTree.cxx:8271
 TTree.cxx:8272
 TTree.cxx:8273
 TTree.cxx:8274
 TTree.cxx:8275
 TTree.cxx:8276
 TTree.cxx:8277
 TTree.cxx:8278
 TTree.cxx:8279
 TTree.cxx:8280
 TTree.cxx:8281
 TTree.cxx:8282
 TTree.cxx:8283
 TTree.cxx:8284
 TTree.cxx:8285
 TTree.cxx:8286
 TTree.cxx:8287
 TTree.cxx:8288
 TTree.cxx:8289
 TTree.cxx:8290
 TTree.cxx:8291
 TTree.cxx:8292
 TTree.cxx:8293
 TTree.cxx:8294
 TTree.cxx:8295
 TTree.cxx:8296
 TTree.cxx:8297
 TTree.cxx:8298
 TTree.cxx:8299
 TTree.cxx:8300
 TTree.cxx:8301
 TTree.cxx:8302
 TTree.cxx:8303
 TTree.cxx:8304
 TTree.cxx:8305
 TTree.cxx:8306
 TTree.cxx:8307
 TTree.cxx:8308
 TTree.cxx:8309
 TTree.cxx:8310
 TTree.cxx:8311
 TTree.cxx:8312
 TTree.cxx:8313
 TTree.cxx:8314
 TTree.cxx:8315
 TTree.cxx:8316
 TTree.cxx:8317
 TTree.cxx:8318
 TTree.cxx:8319
 TTree.cxx:8320
 TTree.cxx:8321
 TTree.cxx:8322
 TTree.cxx:8323
 TTree.cxx:8324
 TTree.cxx:8325
 TTree.cxx:8326
 TTree.cxx:8327
 TTree.cxx:8328
 TTree.cxx:8329
 TTree.cxx:8330
 TTree.cxx:8331
 TTree.cxx:8332
 TTree.cxx:8333
 TTree.cxx:8334
 TTree.cxx:8335
 TTree.cxx:8336
 TTree.cxx:8337
 TTree.cxx:8338
 TTree.cxx:8339
 TTree.cxx:8340
 TTree.cxx:8341
 TTree.cxx:8342
 TTree.cxx:8343
 TTree.cxx:8344
 TTree.cxx:8345
 TTree.cxx:8346
 TTree.cxx:8347
 TTree.cxx:8348
 TTree.cxx:8349
 TTree.cxx:8350
 TTree.cxx:8351
 TTree.cxx:8352
 TTree.cxx:8353
 TTree.cxx:8354
 TTree.cxx:8355
 TTree.cxx:8356
 TTree.cxx:8357
 TTree.cxx:8358
 TTree.cxx:8359
 TTree.cxx:8360
 TTree.cxx:8361
 TTree.cxx:8362
 TTree.cxx:8363
 TTree.cxx:8364
 TTree.cxx:8365
 TTree.cxx:8366
 TTree.cxx:8367
 TTree.cxx:8368
 TTree.cxx:8369
 TTree.cxx:8370
 TTree.cxx:8371
 TTree.cxx:8372
 TTree.cxx:8373
 TTree.cxx:8374
 TTree.cxx:8375
 TTree.cxx:8376
 TTree.cxx:8377
 TTree.cxx:8378
 TTree.cxx:8379
 TTree.cxx:8380
 TTree.cxx:8381
 TTree.cxx:8382
 TTree.cxx:8383
 TTree.cxx:8384
 TTree.cxx:8385
 TTree.cxx:8386
 TTree.cxx:8387
 TTree.cxx:8388
 TTree.cxx:8389
 TTree.cxx:8390
 TTree.cxx:8391
 TTree.cxx:8392
 TTree.cxx:8393
 TTree.cxx:8394
 TTree.cxx:8395
 TTree.cxx:8396
 TTree.cxx:8397
 TTree.cxx:8398
 TTree.cxx:8399
 TTree.cxx:8400
 TTree.cxx:8401
 TTree.cxx:8402
 TTree.cxx:8403
 TTree.cxx:8404
 TTree.cxx:8405
 TTree.cxx:8406
 TTree.cxx:8407
 TTree.cxx:8408
 TTree.cxx:8409
 TTree.cxx:8410
 TTree.cxx:8411
 TTree.cxx:8412
 TTree.cxx:8413
 TTree.cxx:8414
 TTree.cxx:8415
 TTree.cxx:8416
 TTree.cxx:8417
 TTree.cxx:8418
 TTree.cxx:8419
 TTree.cxx:8420
 TTree.cxx:8421
 TTree.cxx:8422
 TTree.cxx:8423
 TTree.cxx:8424
 TTree.cxx:8425
 TTree.cxx:8426
 TTree.cxx:8427
 TTree.cxx:8428
 TTree.cxx:8429
 TTree.cxx:8430
 TTree.cxx:8431
 TTree.cxx:8432
 TTree.cxx:8433
 TTree.cxx:8434
 TTree.cxx:8435
 TTree.cxx:8436
 TTree.cxx:8437
 TTree.cxx:8438
 TTree.cxx:8439
 TTree.cxx:8440
 TTree.cxx:8441
 TTree.cxx:8442
 TTree.cxx:8443
 TTree.cxx:8444
 TTree.cxx:8445
 TTree.cxx:8446
 TTree.cxx:8447
 TTree.cxx:8448
 TTree.cxx:8449
 TTree.cxx:8450
 TTree.cxx:8451
 TTree.cxx:8452
 TTree.cxx:8453
 TTree.cxx:8454
 TTree.cxx:8455
 TTree.cxx:8456
 TTree.cxx:8457
 TTree.cxx:8458
 TTree.cxx:8459
 TTree.cxx:8460
 TTree.cxx:8461
 TTree.cxx:8462
 TTree.cxx:8463
 TTree.cxx:8464
 TTree.cxx:8465
 TTree.cxx:8466
 TTree.cxx:8467
 TTree.cxx:8468
 TTree.cxx:8469
 TTree.cxx:8470
 TTree.cxx:8471
 TTree.cxx:8472
 TTree.cxx:8473
 TTree.cxx:8474
 TTree.cxx:8475
 TTree.cxx:8476
 TTree.cxx:8477
 TTree.cxx:8478
 TTree.cxx:8479
 TTree.cxx:8480
 TTree.cxx:8481
 TTree.cxx:8482
 TTree.cxx:8483
 TTree.cxx:8484
 TTree.cxx:8485
 TTree.cxx:8486
 TTree.cxx:8487
 TTree.cxx:8488
 TTree.cxx:8489
 TTree.cxx:8490
 TTree.cxx:8491
 TTree.cxx:8492
 TTree.cxx:8493
 TTree.cxx:8494
 TTree.cxx:8495
 TTree.cxx:8496
 TTree.cxx:8497
 TTree.cxx:8498
 TTree.cxx:8499
 TTree.cxx:8500
 TTree.cxx:8501
 TTree.cxx:8502
 TTree.cxx:8503
 TTree.cxx:8504
 TTree.cxx:8505
 TTree.cxx:8506
 TTree.cxx:8507
 TTree.cxx:8508
 TTree.cxx:8509
 TTree.cxx:8510
 TTree.cxx:8511
 TTree.cxx:8512
 TTree.cxx:8513
 TTree.cxx:8514
 TTree.cxx:8515
 TTree.cxx:8516
 TTree.cxx:8517
 TTree.cxx:8518
 TTree.cxx:8519
 TTree.cxx:8520
 TTree.cxx:8521
 TTree.cxx:8522
 TTree.cxx:8523
 TTree.cxx:8524
 TTree.cxx:8525
 TTree.cxx:8526
 TTree.cxx:8527
 TTree.cxx:8528
 TTree.cxx:8529
 TTree.cxx:8530
 TTree.cxx:8531
 TTree.cxx:8532
 TTree.cxx:8533
 TTree.cxx:8534
 TTree.cxx:8535
 TTree.cxx:8536
 TTree.cxx:8537
 TTree.cxx:8538
 TTree.cxx:8539
 TTree.cxx:8540
 TTree.cxx:8541
 TTree.cxx:8542
 TTree.cxx:8543
 TTree.cxx:8544
 TTree.cxx:8545
 TTree.cxx:8546
 TTree.cxx:8547
 TTree.cxx:8548
 TTree.cxx:8549
 TTree.cxx:8550
 TTree.cxx:8551
 TTree.cxx:8552
 TTree.cxx:8553
 TTree.cxx:8554
 TTree.cxx:8555
 TTree.cxx:8556
 TTree.cxx:8557
 TTree.cxx:8558
 TTree.cxx:8559
 TTree.cxx:8560
 TTree.cxx:8561
 TTree.cxx:8562
 TTree.cxx:8563
 TTree.cxx:8564
 TTree.cxx:8565
 TTree.cxx:8566
 TTree.cxx:8567
 TTree.cxx:8568
 TTree.cxx:8569
 TTree.cxx:8570
 TTree.cxx:8571
 TTree.cxx:8572
 TTree.cxx:8573
 TTree.cxx:8574
 TTree.cxx:8575
 TTree.cxx:8576
 TTree.cxx:8577
 TTree.cxx:8578
 TTree.cxx:8579
 TTree.cxx:8580
 TTree.cxx:8581
 TTree.cxx:8582
 TTree.cxx:8583
 TTree.cxx:8584
 TTree.cxx:8585
 TTree.cxx:8586
 TTree.cxx:8587
 TTree.cxx:8588
 TTree.cxx:8589
 TTree.cxx:8590
 TTree.cxx:8591
 TTree.cxx:8592
 TTree.cxx:8593
 TTree.cxx:8594
 TTree.cxx:8595
 TTree.cxx:8596
 TTree.cxx:8597
 TTree.cxx:8598
 TTree.cxx:8599
 TTree.cxx:8600
 TTree.cxx:8601
 TTree.cxx:8602
 TTree.cxx:8603
 TTree.cxx:8604
 TTree.cxx:8605
 TTree.cxx:8606
 TTree.cxx:8607
 TTree.cxx:8608
 TTree.cxx:8609
 TTree.cxx:8610
 TTree.cxx:8611
 TTree.cxx:8612
 TTree.cxx:8613
 TTree.cxx:8614
 TTree.cxx:8615
 TTree.cxx:8616
 TTree.cxx:8617
 TTree.cxx:8618
 TTree.cxx:8619
 TTree.cxx:8620
 TTree.cxx:8621
 TTree.cxx:8622
 TTree.cxx:8623
 TTree.cxx:8624
 TTree.cxx:8625
 TTree.cxx:8626
 TTree.cxx:8627
 TTree.cxx:8628
 TTree.cxx:8629
 TTree.cxx:8630
 TTree.cxx:8631
 TTree.cxx:8632
 TTree.cxx:8633
 TTree.cxx:8634
 TTree.cxx:8635
 TTree.cxx:8636
 TTree.cxx:8637
 TTree.cxx:8638
 TTree.cxx:8639
 TTree.cxx:8640
 TTree.cxx:8641
 TTree.cxx:8642
 TTree.cxx:8643
 TTree.cxx:8644
 TTree.cxx:8645
 TTree.cxx:8646
 TTree.cxx:8647
 TTree.cxx:8648
 TTree.cxx:8649
 TTree.cxx:8650
 TTree.cxx:8651
 TTree.cxx:8652
 TTree.cxx:8653
 TTree.cxx:8654
 TTree.cxx:8655
 TTree.cxx:8656
 TTree.cxx:8657
 TTree.cxx:8658
 TTree.cxx:8659
 TTree.cxx:8660
 TTree.cxx:8661
 TTree.cxx:8662
 TTree.cxx:8663
 TTree.cxx:8664
 TTree.cxx:8665
 TTree.cxx:8666
 TTree.cxx:8667
 TTree.cxx:8668
 TTree.cxx:8669
 TTree.cxx:8670
 TTree.cxx:8671
 TTree.cxx:8672
 TTree.cxx:8673
 TTree.cxx:8674
 TTree.cxx:8675
 TTree.cxx:8676
 TTree.cxx:8677
 TTree.cxx:8678
 TTree.cxx:8679
 TTree.cxx:8680
 TTree.cxx:8681
 TTree.cxx:8682
 TTree.cxx:8683
 TTree.cxx:8684
 TTree.cxx:8685
 TTree.cxx:8686
 TTree.cxx:8687
 TTree.cxx:8688
 TTree.cxx:8689
 TTree.cxx:8690
 TTree.cxx:8691
 TTree.cxx:8692
 TTree.cxx:8693
 TTree.cxx:8694
 TTree.cxx:8695
 TTree.cxx:8696
 TTree.cxx:8697
 TTree.cxx:8698