ROOT logo
// @(#)root/tree:$Id: TChain.cxx 28842 2009-06-07 14:20:07Z pcanal $
// Author: Rene Brun   03/02/97

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

//////////////////////////////////////////////////////////////////////////
//                                                                      //
// TChain                                                               //
//                                                                      //
// A chain is a collection of files containg TTree objects.             //
// When the chain is created, the first parameter is the default name   //
// for the Tree to be processed later on.                               //
//                                                                      //
// Enter a new element in the chain via the TChain::Add function.       //
// Once a chain is defined, one can use the normal TTree functions      //
// to Draw,Scan,etc.                                                    //
//                                                                      //
// Use TChain::SetBranchStatus to activate one or more branches for all //
// the trees in the chain.                                              //
//                                                                      //
//////////////////////////////////////////////////////////////////////////

#include "TChain.h"

#include "TBranch.h"
#include "TBrowser.h"
#include "TChainElement.h"
#include "TClass.h"
#include "TCut.h"
#include "TError.h"
#include "TMath.h"
#include "TFile.h"
#include "TFileInfo.h"
#include "TFriendElement.h"
#include "TLeaf.h"
#include "TList.h"
#include "TObjString.h"
#include "TPluginManager.h"
#include "TROOT.h"
#include "TRegexp.h"
#include "TSelector.h"
#include "TSystem.h"
#include "TTree.h"
#include "TTreeCloner.h"
#include "TTreeCache.h"
#include "TUrl.h"
#include "TVirtualIndex.h"
#include "TEventList.h"
#include "TEntryList.h"
#include "TEntryListFromFile.h"
#include "TFileStager.h"

const Long64_t theBigNumber = Long64_t(1234567890)<<28;

ClassImp(TChain)

//______________________________________________________________________________
TChain::TChain()
: TTree()
, fTreeOffsetLen(100)
, fNtrees(0)
, fTreeNumber(-1)
, fTreeOffset(0)
, fCanDeleteRefs(kFALSE)
, fTree(0)
, fFile(0)
, fFiles(0)
, fStatus(0)
, fProofChain(0)
{
   // -- Default constructor.

   fTreeOffset = new Long64_t[fTreeOffsetLen];
   fFiles = new TObjArray(fTreeOffsetLen);
   fStatus = new TList();
   fTreeOffset[0]  = 0;
   gDirectory->Remove(this);
   gROOT->GetListOfSpecials()->Add(this);
   fFile = 0;
   fDirectory = 0;

   // Reset PROOF-related bits
   ResetBit(kProofUptodate);
   ResetBit(kProofLite);

   // Add to the global list
   gROOT->GetListOfDataSets()->Add(this);
}

//______________________________________________________________________________
TChain::TChain(const char* name, const char* title)
:TTree(name, title)
, fTreeOffsetLen(100)
, fNtrees(0)
, fTreeNumber(-1)
, fTreeOffset(0)
, fCanDeleteRefs(kFALSE)
, fTree(0)
, fFile(0)
, fFiles(0)
, fStatus(0)
, fProofChain(0)
{
   // -- Create a chain.
   //
   //   A TChain is a collection of TFile objects.
   //    the first parameter "name" is the name of the TTree object
   //    in the files added with Add.
   //   Use TChain::Add to add a new element to this chain.
   //
   //   In case the Tree is in a subdirectory, do, eg:
   //     TChain ch("subdir/treename");
   //
   //    Example:
   //  Suppose we have 3 files f1.root, f2.root and f3.root. Each file
   //  contains a TTree object named "T".
   //     TChain ch("T");  creates a chain to process a Tree called "T"
   //     ch.Add("f1.root");
   //     ch.Add("f2.root");
   //     ch.Add("f3.root");
   //     ch.Draw("x");
   //       The Draw function above will process the variable "x" in Tree "T"
   //       reading sequentially the 3 files in the chain ch.
   //
   //   The TChain data structure
   //       Each TChainElement has a name equal to the tree name of this TChain
   //       and a title equal to the file name. So, to loop over the
   //       TFiles that have been added to this chain:
   //
   //         TObjArray *fileElements=chain->GetListOfFiles();
   //         TIter next(fileElements);
   //         TChainElement *chEl=0;
   //         while (( chEl=(TChainElement*)next() )) {
   //            TFile f(chEl->GetTitle());
   //            ... do something with f ...
   //         }

   //
   //*-*

   fTreeOffset = new Long64_t[fTreeOffsetLen];
   fFiles = new TObjArray(fTreeOffsetLen);
   fStatus = new TList();
   fTreeOffset[0]  = 0;
   gDirectory->Remove(this);
   gROOT->GetListOfSpecials()->Add(this);
   fFile = 0;
   fDirectory = 0;

   // Reset PROOF-related bits
   ResetBit(kProofUptodate);
   ResetBit(kProofLite);

   // Add to the global list
   gROOT->GetListOfDataSets()->Add(this);
}

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

   SafeDelete(fProofChain);
   fStatus->Delete();
   delete fStatus;
   fStatus = 0;
   fFiles->Delete();
   delete fFiles;
   fFiles = 0;
   delete fFile;
   fFile = 0;
   // Note: We do *not* own the tree.
   fTree = 0;
   delete[] fTreeOffset;
   fTreeOffset = 0;

   gROOT->GetListOfSpecials()->Remove(this);

   // Remove from the global list
   gROOT->GetListOfDataSets()->Remove(this);

   // This is the same as fFile, don't delete it a second time.
   fDirectory = 0;
}

//______________________________________________________________________________
Int_t TChain::Add(TChain* chain)
{
   // -- Add all files referenced by the passed chain to this chain.
   // The function returns the total number of files connected.

   // Check for enough space in fTreeOffset.
   if ((fNtrees + chain->GetNtrees()) >= fTreeOffsetLen) {
      fTreeOffsetLen += 2 * chain->GetNtrees();
      Long64_t* trees = new Long64_t[fTreeOffsetLen];
      for (Int_t i = 0; i <= fNtrees; i++) {
         trees[i] = fTreeOffset[i];
      }
      delete[] fTreeOffset;
      fTreeOffset = trees;
   }
   TIter next(chain->GetListOfFiles());
   Int_t nf = 0;
   TChainElement* element = 0;
   while ((element = (TChainElement*) next())) {
      Long64_t nentries = element->GetEntries();
      if (fTreeOffset[fNtrees] == theBigNumber) {
         fTreeOffset[fNtrees+1] = theBigNumber;
      } else {
         fTreeOffset[fNtrees+1] = fTreeOffset[fNtrees] + nentries;
      }
      fNtrees++;
      fEntries += nentries;
      TChainElement* newelement = new TChainElement(element->GetName(), element->GetTitle());
      newelement->SetPacketSize(element->GetPacketSize());
      newelement->SetNumberEntries(nentries);
      fFiles->Add(newelement);
      nf++;
   }
   if (fProofChain)
      // This updates the proxy chain when we will really use PROOF
      ResetBit(kProofUptodate);

   return nf;
}

//______________________________________________________________________________
Int_t TChain::Add(const char* name, Long64_t nentries /* = kBigNumber */)
{
   // -- Add a new file to this chain.
   //
   // Argument name may have the following format:
   //   //machine/file_name.root/subdir/tree_name
   // machine, subdir and tree_name are optional. If tree_name is missing,
   // the chain name will be assumed.
   // In the file name part (but not in preceding directories) wildcarding
   // notation may be used, eg. specifying "xxx*.root" adds all files starting
   // with xxx in the current file system directory.
   // NB. To add all the files of a TChain to a chain, use Add(TChain *chain).
   //
   //    A- if nentries <= 0, the file is connected and the tree header read
   //       in memory to get the number of entries.
   //
   //    B- if (nentries > 0, the file is not connected, nentries is assumed to be
   //       the number of entries in the file. In this case, no check is made that
   //       the file exists and the Tree existing in the file. This second mode
   //       is interesting in case the number of entries in the file is already stored
   //       in a run data base for example.
   //
   //    C- if (nentries == kBigNumber) (default), the file is not connected.
   //       the number of entries in each file will be read only when the file
   //       will need to be connected to read an entry.
   //       This option is the default and very efficient if one process
   //       the chain sequentially. Note that in case TChain::GetEntry(entry)
   //       is called and entry refers to an entry in the 3rd file, for example,
   //       this forces the Tree headers in the first and second file
   //       to be read to find the number of entries in these files.
   //       Note that if one calls TChain::GetEntriesFast() after having created
   //       a chain with this default, GetEntriesFast will return kBigNumber!
   //       TChain::GetEntries will force of the Tree headers in the chain to be
   //       read to read the number of entries in each Tree.
   //
   //
   //    D- The TChain data structure
   //       Each TChainElement has a name equal to the tree name of this TChain
   //       and a title equal to the file name. So, to loop over the
   //       TFiles that have been added to this chain:
   //
   //         TObjArray *fileElements=chain->GetListOfFiles();
   //         TIter next(fileElements);
   //         TChainElement *chEl=0;
   //         while (( chEl=(TChainElement*)next() )) {
   //            TFile f(chEl->GetTitle());
   //            ... do something with f ...
   //         }
   //
   // The function returns the total number of files connected.

   // case with one single file
   if (!TString(name).MaybeWildcard()) {
      return AddFile(name, nentries);
   }

   // wildcarding used in name
   Int_t nf = 0;
   TString basename(name);

   Int_t dotslashpos = -1;
   {
      Int_t next_dot = basename.Index(".root");
      while(next_dot>=0) {
         dotslashpos = next_dot;
         next_dot = basename.Index(".root",dotslashpos+1);
      }
      if (basename[dotslashpos+5]!='/') {
         // We found the 'last' .root in the name and it is not followed by
         // a '/', so the tree name is _not_ specified in the name.
         dotslashpos = -1;
      }
   }
   //Int_t dotslashpos = basename.Index(".root/");
   TString behind_dot_root;
   if (dotslashpos>=0) {
      // Copy the tree name specification
      behind_dot_root = basename(dotslashpos+6,basename.Length()-dotslashpos+6);
      // and remove it from basename
      basename.Remove(dotslashpos+5);
   }

   Int_t slashpos = basename.Last('/');
   TString directory;
   if (slashpos>=0) {
      directory = basename(0,slashpos); // Copy the directory name
      basename.Remove(0,slashpos+1);      // and remove it from basename
   } else {
      directory = gSystem->UnixPathName(gSystem->WorkingDirectory());
   }

   const char *file;
   void *dir = gSystem->OpenDirectory(gSystem->ExpandPathName(directory.Data()));

   if (dir) {
      //create a TList to store the file names (not yet sorted)
      TList l;
      TRegexp re(basename,kTRUE);
      while ((file = gSystem->GetDirEntry(dir))) {
         if (!strcmp(file,".") || !strcmp(file,"..")) continue;
         TString s = file;
         if ( (basename!=file) && s.Index(re) == kNPOS) continue;
         l.Add(new TObjString(file));
      }
      gSystem->FreeDirectory(dir);
      //sort the files in alphanumeric order
      l.Sort();
      TIter next(&l);
      TObjString *obj;
      while ((obj = (TObjString*)next())) {
         file = obj->GetName();
         if (behind_dot_root.Length() != 0)
            nf += AddFile(Form("%s/%s/%s",directory.Data(),file,behind_dot_root.Data()),kBigNumber);
         else
            nf += AddFile(Form("%s/%s",directory.Data(),file),kBigNumber);
      }
      l.Delete();
   }
   if (fProofChain)
      // This updates the proxy chain when we will really use PROOF
      ResetBit(kProofUptodate);

   return nf;
}

//______________________________________________________________________________
Int_t TChain::AddFile(const char* name, Long64_t nentries /* = kBigNumber */, const char* tname /* = "" */)
{
   // -- Add a new file to this chain.
   //
   //    If tname is specified, the chain will load the tree named tname
   //    from the file, otherwise the original treename specified in the
   //    TChain constructor will be used.
   //
   // A. If nentries <= 0, the file is opened and the tree header read
   //    into memory to get the number of entries.
   //
   // B. If nentries > 0, the file is not opened, and nentries is assumed
   //    to be the number of entries in the file. In this case, no check
   //    is made that the file exists nor that the tree exists in the file.
   //    This second mode is interesting in case the number of entries in
   //    the file is already stored in a run database for example.
   //
   // C. If nentries == kBigNumber (default), the file is not opened.
   //    The number of entries in each file will be read only when the file
   //    is opened to read an entry.  This option is the default and very
   //    efficient if one processes the chain sequentially.  Note that in
   //    case GetEntry(entry) is called and entry refers to an entry in the
   //    third file, for example, this forces the tree headers in the first
   //    and second file to be read to find the number of entries in those
   //    files.  Note that if one calls GetEntriesFast() after having created
   //    a chain with this default, GetEntriesFast() will return kBigNumber!
   //    Using the GetEntries() function instead will force all of the tree
   //    headers in the chain to be read to read the number of entries in
   //    each tree.
   //
   // D. The TChain data structure
   //    Each TChainElement has a name equal to the tree name of this TChain
   //    and a title equal to the file name. So, to loop over the
   //    TFiles that have been added to this chain:
   //
   //      TObjArray *fileElements=chain->GetListOfFiles();
   //      TIter next(fileElements);
   //      TChainElement *chEl=0;
   //      while (( chEl=(TChainElement*)next() )) {
   //         TFile f(chEl->GetTitle());
   //         ... do something with f ...
   //      }
   //
   // The function returns 1 if the file is successfully connected, 0 otherwise.


   const char *treename = GetName();
   if (tname && strlen(tname) > 0) treename = tname;
   char *dot = 0;
   {
      char *nextdot =  (char*)strstr(name,".root");
      while (nextdot) {
         dot = nextdot;
         nextdot = (char*)strstr(dot+1,".root");
      }
   }
   //the ".root" is mandatory only if one wants to specify a treename
   //if (!dot) {
   //   Error("AddFile","a chain element name must contain the string .root");
   //   return 0;
   //}

   //Check enough space in fTreeOffset
   if (fNtrees+1 >= fTreeOffsetLen) {
      fTreeOffsetLen *= 2;
      Long64_t *trees = new Long64_t[fTreeOffsetLen];
      for (Int_t i=0;i<=fNtrees;i++) trees[i] = fTreeOffset[i];
      delete [] fTreeOffset;
      fTreeOffset = trees;
   }

   //Search for a a slash between the .root and the end
   Int_t nch = strlen(name) + strlen(treename);
   char *filename = new char[nch+1];
   strcpy(filename,name);
   if (dot) {
      char *pos = filename + (dot-name) + 5;
      while (*pos) {
         if (*pos == '/') {
            treename = pos+1;
            *pos = 0;
            break;
         }
         pos++;
      }
   }

   // Open the file to get the number of entries.
   Int_t pksize = 0;
   if (nentries <= 0) {
      TFile* file;
      {
         TDirectory::TContext ctxt(0);
         file = TFile::Open(filename);
      }
      if (!file || file->IsZombie()) {
         delete file;
         file = 0;
         delete[] filename;
         filename = 0;
         return 0;
      }

      // Check that tree with the right name exists in the file.
      // Note: We are not the owner of obj, the file is!
      TObject* obj = file->Get(treename);
      if (!obj || !obj->InheritsFrom("TTree")) {
         Error("AddFile", "cannot find tree with name %s in file %s", treename, filename);
         delete file;
         file = 0;
         delete[] filename;
         filename = 0;
         return 0;
      }
      TTree* tree = (TTree*) obj;
      nentries = tree->GetEntries();
      pksize = tree->GetPacketSize();
      // Note: This deletes the tree we fetched.
      delete file;
      file = 0;
   }

   if (nentries > 0) {
      if (nentries != kBigNumber) {
         fTreeOffset[fNtrees+1] = fTreeOffset[fNtrees] + nentries;
         fEntries += nentries;
      } else {
         fTreeOffset[fNtrees+1] = theBigNumber;
         fEntries = nentries;
      }
      fNtrees++;

      TChainElement* element = new TChainElement(treename, filename);
      element->SetPacketSize(pksize);
      element->SetNumberEntries(nentries);
      fFiles->Add(element);
   } else {
      Warning("AddFile", "Adding tree with no entries from file: %s", filename);
   }

   delete [] filename;
   if (fProofChain)
      // This updates the proxy chain when we will really use PROOF
      ResetBit(kProofUptodate);

   return 1;
}

//______________________________________________________________________________
Int_t TChain::AddFileInfoList(TCollection* filelist, Long64_t nfiles /* = kBigNumber */)
{
   // Add all files referenced in the list to the chain. The object type in the
   // list must be either TFileInfo or TObjString or TUrl .
   // The function return 1 if successful, 0 otherwise.
   if (!filelist)
      return 0;
   TIter next(filelist);

   TObject *o = 0;
   Long64_t cnt=0;
   while ((o = next())) {
      // Get the url
      TString cn = o->ClassName();
      const char *url = 0;
      if (cn == "TFileInfo") {
         TFileInfo *fi = (TFileInfo *)o;
         url = (fi->GetCurrentUrl()) ? fi->GetCurrentUrl()->GetUrl() : 0;
         if (!url) {
            Warning("AddFileInfoList", "found TFileInfo with empty Url - ignoring");
            continue;
         }
      } else if (cn == "TUrl") {
         url = ((TUrl*)o)->GetUrl();
      } else if (cn == "TObjString") {
         url = ((TObjString*)o)->GetName();
      }
      if (!url) {
         Warning("AddFileInfoList", "object is of type %s : expecting TFileInfo, TUrl"
                                 " or TObjString - ignoring", o->ClassName());
         continue;
      }
      // Good entry
      cnt++;
      AddFile(url);
      if (cnt >= nfiles)
         break;
   }
   if (fProofChain) {
      // This updates the proxy chain when we will really use PROOF
      ResetBit(kProofUptodate);
   }

   return 1;
}

//______________________________________________________________________________
TFriendElement* TChain::AddFriend(const char* chain, const char* dummy /* = "" */)
{
   // -- Add a TFriendElement to the list of friends of this chain.
   //
   // A TChain has a list of friends similar to a tree (see TTree::AddFriend).
   // You can add a friend to a chain with the TChain::AddFriend method, and you
   // can retrieve the list of friends with TChain::GetListOfFriends.
   // This example has four chains each has 20 ROOT trees from 20 ROOT files.
   //
   // TChain ch("t"); // a chain with 20 trees from 20 files
   // TChain ch1("t1");
   // TChain ch2("t2");
   // TChain ch3("t3");
   // Now we can add the friends to the first chain.
   //
   // ch.AddFriend("t1")
   // ch.AddFriend("t2")
   // ch.AddFriend("t3")
   //
   //Begin_Html
   /*
   <img src="gif/chain_friend.gif">
   */
   //End_Html
   //
   // The parameter is the name of friend chain (the name of a chain is always
   // the name of the tree from which it was created).
   // The original chain has access to all variable in its friends.
   // We can use the TChain::Draw method as if the values in the friends were
   // in the original chain.
   // To specify the chain to use in the Draw method, use the syntax:
   //
   // <chainname>.<branchname>.<varname>
   // If the variable name is enough to uniquely identify the variable, you can
   // leave out the chain and/or branch name.
   // For example, this generates a 3-d scatter plot of variable "var" in the
   // TChain ch versus variable v1 in TChain t1 versus variable v2 in TChain t2.
   //
   // ch.Draw("var:t1.v1:t2.v2");
   // When a TChain::Draw is executed, an automatic call to TTree::AddFriend
   // connects the trees in the chain. When a chain is deleted, its friend
   // elements are also deleted.
   //
   // The number of entries in the friend must be equal or greater to the number
   // of entries of the original chain. If the friend has fewer entries a warning
   // is given and the resulting histogram will have missing entries.
   // For additional information see TTree::AddFriend.

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

   R__ASSERT(fe); // There used to be a "if (fe)" test ... Keep this assert until we are sure that fe is never null

   fFriends->Add(fe);

   if (fProofChain)
      // This updates the proxy chain when we will really use PROOF
      ResetBit(kProofUptodate);

   // We need to invalidate the loading of the current tree because its list
   // of real friends is now obsolete.  It is repairable only from LoadTree.
   fTreeNumber = -1;

   TTree* tree = fe->GetTree();
   if (!tree) {
      Warning("AddFriend", "Unknown TChain %s", chain);
   }
   return fe;
}

//______________________________________________________________________________
TFriendElement* TChain::AddFriend(const char* chain, TFile* dummy)
{
   // -- Add the whole chain or tree as a friend of this chain.

   if (!fFriends) fFriends = new TList();
   TFriendElement *fe = new TFriendElement(this,chain,dummy);

   R__ASSERT(fe); // There used to be a "if (fe)" test ... Keep this assert until we are sure that fe is never null

   fFriends->Add(fe);

   if (fProofChain)
      // This updates the proxy chain when we will really use PROOF
      ResetBit(kProofUptodate);

   // We need to invalidate the loading of the current tree because its list
   // of real friend is now obsolete.  It is repairable only from LoadTree
   fTreeNumber = -1;

   TTree *t = fe->GetTree();
   if (!t) {
      Warning("AddFriend","Unknown TChain %s",chain);
   }
   return fe;
}

//______________________________________________________________________________
TFriendElement* TChain::AddFriend(TTree* chain, const char* alias, Bool_t /* warn = kFALSE */)
{
   // -- Add the whole chain or tree as a friend of this chain.

   if (!fFriends) fFriends = new TList();
   TFriendElement *fe = new TFriendElement(this,chain,alias);
   R__ASSERT(fe);

   fFriends->Add(fe);

   if (fProofChain)
      // This updates the proxy chain when we will really use PROOF
      ResetBit(kProofUptodate);

   // We need to invalidate the loading of the current tree because its list
   // of real friend is now obsolete.  It is repairable only from LoadTree
   fTreeNumber = -1;

   TTree *t = fe->GetTree();
   if (!t) {
      Warning("AddFriend","Unknown TChain %s",chain->GetName());
   }
   return fe;
}

//______________________________________________________________________________
void TChain::Browse(TBrowser* b)
{
   // -- Browse the contents of the chain.

   TTree::Browse(b);
}

//_______________________________________________________________________
void TChain::CanDeleteRefs(Bool_t flag /* = kTRUE */)
{
   // When closing a file during the chain processing, the file
   // may be closed with option "R" if flag is set to kTRUE.
   // by default flag is kTRUE.
   // When closing a file with option "R", all TProcessIDs referenced by this
   // file are deleted.
   // Calling TFile::Close("R") might be necessary in case one reads a long list
   // of files having TRef, writing some of the referenced objects or TRef
   // to a new file. If the TRef or referenced objects of the file being closed
   // will not be referenced again, it is possible to minimize the size
   // of the TProcessID data structures in memory by forcing a delete of
   // the unused TProcessID.

   fCanDeleteRefs = flag;
}

//_______________________________________________________________________
void TChain::CreatePackets()
{
   // -- Initialize the packet descriptor string.

   TIter next(fFiles);
   TChainElement* element = 0;
   while ((element = (TChainElement*) next())) {
      element->CreatePackets();
   }
}

//______________________________________________________________________________
void TChain::DirectoryAutoAdd(TDirectory * /* dir */)
{
   // Override the TTree::DirectoryAutoAdd behavior:
   // we never auto add.

}

//______________________________________________________________________________
Long64_t TChain::Draw(const char* varexp, const TCut& selection,
                      Option_t* option, Long64_t nentries, Long64_t firstentry)
{
   // Draw expression varexp for selected 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);
   //
   if (fProofChain) {
      // Make sure the element list is uptodate
      if (!TestBit(kProofUptodate))
         SetProof(kTRUE, kTRUE);
      fProofChain->SetEventList(fEventList);
      fProofChain->SetEntryList(fEntryList);
      return fProofChain->Draw(varexp, selection, option, nentries, firstentry);
   }

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

//______________________________________________________________________________
Long64_t TChain::Draw(const char* varexp, const char* selection,
                      Option_t* option,Long64_t nentries, Long64_t firstentry)
{
   // Process all entries in this chain and draw histogram corresponding to
   // expression varexp.
   // Returns -1 in case of error or number of selected events in case of success.

   if (fProofChain) {
      // Make sure the element list is uptodate
      if (!TestBit(kProofUptodate))
         SetProof(kTRUE, kTRUE);
      fProofChain->SetEventList(fEventList);
      fProofChain->SetEntryList(fEntryList);
      return fProofChain->Draw(varexp, selection, option, nentries, firstentry);
   }
   GetPlayer();
   if (LoadTree(firstentry) < 0) return 0;
   return TTree::Draw(varexp,selection,option,nentries,firstentry);
}

//______________________________________________________________________________
TBranch* TChain::FindBranch(const char* branchname)
{
   // -- See TTree::GetReadEntry().

   if (fProofChain && !(fProofChain->TestBit(kProofLite))) {
      // Make sure the element list is uptodate
      if (!TestBit(kProofUptodate))
         SetProof(kTRUE, kTRUE);
      return fProofChain->FindBranch(branchname);
   }
   if (fTree) {
      return fTree->FindBranch(branchname);
   }
   LoadTree(0);
   if (fTree) {
      return fTree->FindBranch(branchname);
   }
   return 0;
}

//______________________________________________________________________________
TLeaf* TChain::FindLeaf(const char* searchname)
{
   // -- See TTree::GetReadEntry().

   if (fProofChain && !(fProofChain->TestBit(kProofLite))) {
      // Make sure the element list is uptodate
      if (!TestBit(kProofUptodate))
         SetProof(kTRUE, kTRUE);
      return fProofChain->FindLeaf(searchname);
   }
   if (fTree) {
      return fTree->FindLeaf(searchname);
   }
   LoadTree(0);
   if (fTree) {
      return fTree->FindLeaf(searchname);
   }
   return 0;
}

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

   const char* alias = TTree::GetAlias(aliasName);
   if (alias) {
      return alias;
   }
   if (fTree) {
      return fTree->GetAlias(aliasName);
   }
   const_cast<TChain*>(this)->LoadTree(0);
   if (fTree) {
      return fTree->GetAlias(aliasName);
   }
   return 0;
}

//______________________________________________________________________________
TBranch* TChain::GetBranch(const char* name)
{
   // -- Return pointer to the branch name in the current tree.

   if (fProofChain && !(fProofChain->TestBit(kProofLite))) {
      // Make sure the element list is uptodate
      if (!TestBit(kProofUptodate))
         SetProof(kTRUE, kTRUE);
      return fProofChain->GetBranch(name);
   }
   if (fTree) {
      return fTree->GetBranch(name);
   }
   LoadTree(0);
   if (fTree) {
      return fTree->GetBranch(name);
   }
   return 0;
}

//______________________________________________________________________________
Bool_t TChain::GetBranchStatus(const char* branchname) const
{
   // -- See TTree::GetReadEntry().
   if (fProofChain && !(fProofChain->TestBit(kProofLite))) {
      // Make sure the element list is uptodate
      if (!TestBit(kProofUptodate))
         Warning("GetBranchStatus", "PROOF proxy not up-to-date:"
                                    " run TChain::SetProof(kTRUE, kTRUE) first");
      return fProofChain->GetBranchStatus(branchname);
   }
   return TTree::GetBranchStatus(branchname);
}

//______________________________________________________________________________
Long64_t TChain::GetChainEntryNumber(Long64_t entry) const
{
   // -- Return absolute entry number in the chain.
   // The input parameter entry is the entry number in
   // the current tree of this chain.

   return entry + fTreeOffset[fTreeNumber];
}

//______________________________________________________________________________
Long64_t TChain::GetEntries() const
{
   // -- Return the total number of entries in the chain.
   // In case the number of entries in each tree is not yet known,
   // the offset table is computed.

   if (fProofChain && !(fProofChain->TestBit(kProofLite))) {
      // Make sure the element list is uptodate
      if (!TestBit(kProofUptodate))
         Warning("GetEntries", "PROOF proxy not up-to-date:"
                               " run TChain::SetProof(kTRUE, kTRUE) first");
      return fProofChain->GetEntries();
   }
   if (fEntries >= theBigNumber || fEntries==kBigNumber) {
      const_cast<TChain*>(this)->LoadTree(theBigNumber-1);
   }
   return fEntries;
}

//______________________________________________________________________________
Int_t TChain::GetEntry(Long64_t entry, Int_t getall)
{
   // -- Get entry from the file to memory.
   //
   //     getall = 0 : get only active branches
   //     getall = 1 : get all branches
   //
   // Return the total number of bytes read,
   // 0 bytes read indicates a failure.

   Long64_t treeReadEntry = LoadTree(entry);
   if (treeReadEntry < 0) {
      return 0;
   }
   if (!fTree) {
      return 0;
   }
   return fTree->GetEntry(treeReadEntry, getall);
}

//______________________________________________________________________________
Long64_t TChain::GetEntryNumber(Long64_t entry) const
{
   // -- Return entry number corresponding to entry.
   //
   // if no TEntryList set returns entry
   // else returns entry #entry from this entry list and
   // also computes the global entry number (loads all tree headers)


   if (fEntryList){
      Int_t treenum = 0;
      Long64_t localentry = fEntryList->GetEntryAndTree(entry, treenum);
      //find the global entry number
      //same const_cast as in the GetEntries() function
      if (localentry<0) return -1;
      if (treenum != fTreeNumber){
         if (fTreeOffset[treenum]==theBigNumber){
            for (Int_t i=0; i<=treenum; i++){
               if (fTreeOffset[i]==theBigNumber)
                  (const_cast<TChain*>(this))->LoadTree(fTreeOffset[i-1]);
            }
         }
         //(const_cast<TChain*>(this))->LoadTree(fTreeOffset[treenum]);
      }
      Long64_t globalentry = fTreeOffset[treenum] + localentry;
      return globalentry;
   }
   return entry;
}

//______________________________________________________________________________
Int_t TChain::GetEntryWithIndex(Int_t major, Int_t minor)
{
   // -- Return entry corresponding to major and minor number.
   //
   // For example:
   //
   //      Int_t run = 1234;
   //      Int_t event = 345;
   //      Long64_t serial = chain.GetEntryNumberWithIndex(run, event);
   //
   // Now the variable serial is in the range [0,nentries] and one can do
   // chain.GetEntry(serial);
   //
   // WARNING: This function will not work if teh chain has friend chains.

   Long64_t serial = GetEntryNumberWithIndex(major, minor);
   if (serial < 0) return -1;
   return GetEntry(serial);
}

//______________________________________________________________________________
TFile* TChain::GetFile() const
{
   // -- Return a pointer to the current file.
   // If no file is connected, the first file is automatically loaded.

   if (fFile) {
      return fFile;
   }
   // Force opening the first file in the chain.
   const_cast<TChain*>(this)->LoadTree(0);
   return fFile;
}

//______________________________________________________________________________
TLeaf* TChain::GetLeaf(const char* name)
{
   // -- Return a pointer to the leaf name in the current tree.

   if (fProofChain && !(fProofChain->TestBit(kProofLite))) {
      // Make sure the element list is uptodate
      if (!TestBit(kProofUptodate))
         SetProof(kTRUE, kTRUE);
      return fProofChain->GetLeaf(name);
   }
   if (fTree) {
      return fTree->GetLeaf(name);
   }
   LoadTree(0);
   if (fTree) {
      return fTree->GetLeaf(name);
   }
   return 0;
}

//______________________________________________________________________________
TObjArray* TChain::GetListOfBranches()
{
   // -- Return a pointer to the list of branches of the current tree.
   //
   // Warning: May set current tree!
   //
   // Returns 1 on success and 0 on failure.

   if (fProofChain && !(fProofChain->TestBit(kProofLite))) {
      // Make sure the element list is uptodate
      if (!TestBit(kProofUptodate))
         SetProof(kTRUE, kTRUE);
      return fProofChain->GetListOfBranches();
   }
   if (fTree) {
      return fTree->GetListOfBranches();
   }
   LoadTree(0);
   if (fTree) {
      return fTree->GetListOfBranches();
   }
   return 0;
}

//______________________________________________________________________________
TObjArray* TChain::GetListOfLeaves()
{
   // -- Return a pointer to the list of leaves of the current tree.
   //
   // Warning: May set the current tree!
   //

   if (fProofChain && !(fProofChain->TestBit(kProofLite))) {
      // Make sure the element list is uptodate
      if (!TestBit(kProofUptodate))
         SetProof(kTRUE, kTRUE);
      return fProofChain->GetListOfLeaves();
   }
   if (fTree) {
      return fTree->GetListOfLeaves();
   }
   LoadTree(0);
   if (fTree) {
      return fTree->GetListOfLeaves();
   }
   return 0;
}

//______________________________________________________________________________
Double_t TChain::GetMaximum(const char* columname)
{
   // -- Return maximum of column with name columname.

   Double_t theMax = -FLT_MAX;
   for (Int_t file = 0; file < fNtrees; file++) {
      Long64_t first = fTreeOffset[file];
      LoadTree(first);
      Double_t curmax = fTree->GetMaximum(columname);
      if (curmax > theMax) {
         theMax = curmax;
      }
   }
   return theMax;
}

//______________________________________________________________________________
Double_t TChain::GetMinimum(const char* columname)
{
   // -- Return minimum of column with name columname.

   Double_t theMin = FLT_MAX;
   for (Int_t file = 0; file < fNtrees; file++) {
      Long64_t first = fTreeOffset[file];
      LoadTree(first);
      Double_t curmin = fTree->GetMinimum(columname);
      if (curmin < theMin) {
         theMin = curmin;
      }
   }
   return theMin;
}

//______________________________________________________________________________
Int_t TChain::GetNbranches()
{
   // -- Return the number of branches of the current tree.
   //
   // Warning: May set the current tree!
   //

   if (fTree) {
      return fTree->GetNbranches();
   }
   LoadTree(0);
   if (fTree) {
      return fTree->GetNbranches();
   }
   return 0;
}

//______________________________________________________________________________
Long64_t TChain::GetReadEntry() const
{
   // -- See TTree::GetReadEntry().

   if (fProofChain && !(fProofChain->TestBit(kProofLite))) {
      // Make sure the element list is uptodate
      if (!TestBit(kProofUptodate))
         Warning("GetBranchStatus", "PROOF proxy not up-to-date:"
                                    " run TChain::SetProof(kTRUE, kTRUE) first");
      return fProofChain->GetReadEntry();
   }
   return TTree::GetReadEntry();
}

//______________________________________________________________________________
Double_t TChain::GetWeight() const
{
   // -- Return the chain weight.
   //
   // By default the weight is the weight of the current tree.
   // However, if the weight has been set in TChain::SetWeight()
   // with the option "global", then that weight will be returned.
   //
   // Warning: May set the current tree!
   //

   if (TestBit(kGlobalWeight)) {
      return fWeight;
   } else {
      if (fTree) {
         return fTree->GetWeight();
      }
      const_cast<TChain*>(this)->LoadTree(0);
      if (fTree) {
         return fTree->GetWeight();
      }
      return 0;
   }
}

//______________________________________________________________________________
Int_t TChain::LoadBaskets(Long64_t /*maxmemory*/)
{
   // -- Dummy function.
   // It could be implemented and load all baskets of all trees in the chain.
   // For the time being use TChain::Merge and TTree::LoadBasket
   // on the resulting tree.

   Error("LoadBaskets", "Function not yet implemented for TChain.");
   return 0;
}

//______________________________________________________________________________
Long64_t TChain::LoadTree(Long64_t entry)
{
   // -- Find the tree which contains entry, and set it as the current tree.
   //
   // Returns the entry number in that tree.
   //
   // The input argument entry is the entry serial number in the whole chain.
   //
   // Note: This is the only routine which sets the value of fTree to
   //       a non-zero pointer.
   //

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

   if (!fNtrees) {
      // -- The chain is empty.
      return 1;
   }

   if ((entry < 0) || ((entry > 0) && (entry >= fEntries && entry!=(theBigNumber-1) ))) {
      // -- Invalid entry number.
      return -2;
   }

   // Find out which tree in the chain contains the passed entry.
   Int_t treenum = fTreeNumber;
   if ((fTreeNumber == -1) || (entry < fTreeOffset[fTreeNumber]) || (entry >= fTreeOffset[fTreeNumber+1]) || (entry==theBigNumber-1)) {
      // -- Entry is *not* in the chain's current tree.
      // Do a linear search of the tree offset array.
      // FIXME: We could be smarter by starting at the
      //        current tree number and going forwards,
      //        then wrapping around at the end.
      for (treenum = 0; treenum < fNtrees; treenum++) {
         if (entry < fTreeOffset[treenum+1]) {
            break;
         }
      }
   }

   // Calculate the entry number relative to the found tree.
   Long64_t treeReadEntry = entry - fTreeOffset[treenum];
   fReadEntry = entry;

   // If entry belongs to the current tree return entry.
   if (treenum == fTreeNumber) {
      // First set the entry the tree on its owns friends
      // (the friends of the chain will be updated in the
      // next loop).
      fTree->LoadTree(treeReadEntry);
      if (fFriends) {
         // The current tree has not changed but some of its friends might.
         //
         // An alternative would move this code to each of
         // the functions calling LoadTree (and to overload a few more).
         TIter next(fFriends);
         TFriendLock lock(this, kLoadTree);
         TFriendElement* fe = 0;
         TFriendElement* fetree = 0;
         Bool_t needUpdate = kFALSE;
         while ((fe = (TFriendElement*) next())) {
            TObjLink* lnk = 0;
            if (fTree->GetListOfFriends()) {
               lnk = fTree->GetListOfFriends()->FirstLink();
            }
            fetree = 0;
            while (lnk) {
               TObject* obj = lnk->GetObject();
               if (obj->TestBit(TFriendElement::kFromChain) && obj->GetName() && !strcmp(fe->GetName(), obj->GetName())) {
                  fetree = (TFriendElement*) obj;
                  break;
               }
               lnk = lnk->Next();
            }
            TTree* at = fe->GetTree();
            if (at->InheritsFrom(TChain::Class())) {
               Int_t oldNumber = ((TChain*) at)->GetTreeNumber();
               TTree* old = at->GetTree();
               TTree* oldintree = fetree ? fetree->GetTree() : 0;
               at->LoadTreeFriend(entry, this);
               Int_t newNumber = ((TChain*) at)->GetTreeNumber();
               if ((oldNumber != newNumber) || (old != at->GetTree()) || (oldintree && (oldintree != at->GetTree()))) {
                  // We can not compare just the tree pointers because
                  // they could be reused. So we compare the tree
                  // number instead.
                  needUpdate = kTRUE;
                  fTree->RemoveFriend(oldintree);
                  fTree->AddFriend(at->GetTree(), fe->GetName())->SetBit(TFriendElement::kFromChain);
               }
            } else {
               // else we assume it is a simple tree If the tree is a
               // direct friend of the chain, it should be scanned
               // used the chain entry number and NOT the tree entry
               // number (treeReadEntry) hence we redo:
               at->LoadTreeFriend(entry, this);
            }
         }
         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();
            }
         }
      }
      return treeReadEntry;
   }

   // If the tree has clones, copy them into the chain
   // clone list so we can change their branch addresses
   // when necessary.
   //
   // This is to support the syntax:
   //
   //      TTree* clone = chain->GetTree()->CloneTree(0);
   //
   if (fTree && fTree->GetListOfClones()) {
      for (TObjLink* lnk = fTree->GetListOfClones()->FirstLink(); lnk; lnk = lnk->Next()) {
         TTree* clone = (TTree*) lnk->GetObject();
         AddClone(clone);
      }
   }

   // Delete the current tree and open the new tree.
   TTreeCache* tpf = 0;

   // Delete file unless the file owns this chain!
   // FIXME: The "unless" case here causes us to leak memory.
   if (fFile) {
      if (!fDirectory->GetList()->FindObject(this)) {
         tpf = (TTreeCache*) fFile->GetCacheRead();
         if (tpf) tpf->ResetCache();
         fFile->SetCacheRead(0);
         if (fCanDeleteRefs) {
            fFile->Close("R");
         }
         delete fFile;
         fFile = 0;
         // Note: We do *not* own fTree.
         fTree = 0;
      }
   }

   TChainElement* element = (TChainElement*) fFiles->At(treenum);
   if (!element) {
      if (treeReadEntry) {
         return -4;
      }
      // Last attempt, just in case all trees in the chain have 0 entries.
      element = (TChainElement*) fFiles->At(0);
      if (!element) {
         return -4;
      }
   }

   // FIXME: We leak memory here, we've just lost the open file
   //        if we did not delete it above.
   {
      TDirectory::TContext ctxt(0);
      fFile = TFile::Open(element->GetTitle());
   }

   // ----- Begin of modifications by MvL
   Int_t returnCode = 0;
   if (!fFile || fFile->IsZombie()) {
      if (fFile) {
         delete fFile;
         fFile = 0;
      }
      // Note: We do *not* own fTree.
      fTree = 0;
      returnCode = -3;
   } else {
      // Note: We do *not* own fTree after this, the file does!
      fTree = (TTree*) fFile->Get(element->GetName());
      if (!fTree) {
         // Now that we do not check during the addition, we need to check here!
         Error("LoadTree", "Cannot find tree with name %s in file %s", element->GetName(), element->GetTitle());
         delete fFile;
         fFile = 0;
         // We do not return yet so that 'fEntries' can be updated with the
         // sum of the entries of all the other trees.
         returnCode = -4;
      }
   }

   fTreeNumber = treenum;
   // FIXME: We own fFile, we must be careful giving away a pointer to it!
   // FIXME: We may set fDirectory to zero here!
   fDirectory = fFile;

   // Reuse cache from previous file (if any).
   if (tpf) {
      if (fFile) {
         tpf->ResetCache();
         fFile->SetCacheRead(tpf);
         tpf->SetFile(fFile);
         // FIXME: fTree may be zero here.
         tpf->UpdateBranches(fTree);
      } else {
         // FIXME: One of the file in the chain is missing
         // we have no place to hold the pointer to the
         // TTreeCache.
         delete tpf;
         tpf = 0;
         this->SetCacheSize(fCacheSize);
      }
   } else {
      this->SetCacheSize(fCacheSize);
   }

   // Check if fTreeOffset has really been set.
   Long64_t nentries = 0;
   if (fTree) {
      nentries = fTree->GetEntries();
   }

   if (fTreeOffset[fTreeNumber+1] != (fTreeOffset[fTreeNumber] + nentries)) {
      fTreeOffset[fTreeNumber+1] = fTreeOffset[fTreeNumber] + nentries;
      fEntries = fTreeOffset[fNtrees];
      element->SetNumberEntries(nentries);
      // Below we must test >= in case the tree has no entries.
      if (entry >= fTreeOffset[fTreeNumber+1]) {
         if ((fTreeNumber < (fNtrees - 1)) && (entry < fTreeOffset[fTreeNumber+2])) {
            return LoadTree(entry);
         } else {
            treeReadEntry = fReadEntry = -2;
         }
      }
   }

   if (!fTree) {
      // The Error message already issued.  However if we reach here
      // we need to make sure that we do not use fTree.
      //
      // Force a reload of the tree next time.
      fTreeNumber = -1;
      return returnCode;
   }
   // ----- End of modifications by MvL

   // Copy the chain's clone list into the new tree's
   // clone list so that branch addresses stay synchronized.
   if (fClones) {
      for (TObjLink* lnk = fClones->FirstLink(); lnk; lnk = lnk->Next()) {
         TTree* clone = (TTree*) lnk->GetObject();
         ((TChain*) fTree)->TTree::AddClone(clone);
      }
   }

   // Since some of the friends of this chain might simple trees
   // (i.e., not really chains at all), we need to execute this
   // before calling LoadTree(entry) on the friends (so that
   // they use the correct read entry number).

   // Change the new current tree to the new entry.
   fTree->LoadTree(treeReadEntry);

   // Change the chain friends to the new entry.
   if (fFriends) {
      // An alternative would move this code to each of the function
      // calling LoadTree (and to overload a few more).
      TIter next(fFriends);
      TFriendLock lock(this, kLoadTree);
      TFriendElement* fe = 0;
      while ((fe = (TFriendElement*) next())) {
         TTree* t = fe->GetTree();
         if (!t) continue;
         if (t->GetTreeIndex()) {
            t->GetTreeIndex()->UpdateFormulaLeaves(0);
         }
         if (t->GetTree() && t->GetTree()->GetTreeIndex()) {
            t->GetTree()->GetTreeIndex()->UpdateFormulaLeaves(GetTree());
         }
         t->LoadTreeFriend(entry, this);
         TTree* friend_t = t->GetTree();
         if (friend_t) {
            fTree->AddFriend(friend_t, fe->GetName())->SetBit(TFriendElement::kFromChain);
         }
      }
   }

   fTree->SetMakeClass(fMakeClass);
   fTree->SetMaxVirtualSize(fMaxVirtualSize);

   SetChainOffset(fTreeOffset[fTreeNumber]);

   // Set the branch statuses for the newly opened file.
   TIter next(fStatus);
   while ((element = (TChainElement*) next())) {
      Int_t status = element->GetStatus();
      fTree->SetBranchStatus(element->GetName(), status);
   }

   // Set the branch addresses for the newly opened file.
   next.Reset();
   while ((element = (TChainElement*) next())) {
      void* addr = element->GetBaddress();
      if (addr) {
         TBranch* br = fTree->GetBranch(element->GetName());
         TBranch** pp = element->GetBranchPtr();
         if (pp) {
            // FIXME: What if br is zero here?
            *pp = br;
         }
         if (br) {
            // FIXME: We may have to tell the branch it should
            //        not be an owner of the object pointed at.
            br->SetAddress(addr);
            if (TestBit(kAutoDelete)) {
               br->SetAutoDelete(kTRUE);
            }
         }
      }
   }

   // Update the addresses of the chain's cloned trees, if any.
   if (fClones) {
      for (TObjLink* lnk = fClones->FirstLink(); lnk; lnk = lnk->Next()) {
         TTree* clone = (TTree*) lnk->GetObject();
         CopyAddresses(clone);
      }
   }

   // Update list of leaves in all TTreeFormula's of the TTreePlayer (if any).
   if (fPlayer) {
      fPlayer->UpdateFormulaLeaves();
   }

   // Notify user we have switched trees if requested.
   if (fNotify) {
      fNotify->Notify();
   }

   // Return the new local entry number.
   return treeReadEntry;
}

//______________________________________________________________________________
void TChain::Lookup(Bool_t force)
{
   // Check / locate the files in the chain.
   // By default only the files not yet looked up are checked.
   // Use force = kTRUE to check / re-check every file.

   TIter next(fFiles);
   TChainElement* element = 0;
   Int_t nelements = fFiles->GetEntries();
   printf("\n");
   printf("TChain::Lookup - Looking up %d files .... \n", nelements);
   Int_t nlook = 0;
   TFileStager *stg = 0;
   while ((element = (TChainElement*) next())) {
      // Do not do it more than needed
      if (element->HasBeenLookedUp() && !force) continue;
      // Count
      nlook++;
      // Get the Url
      TUrl elemurl(element->GetTitle());
      // Save current options and anchor
      TString anchor = elemurl.GetAnchor();
      TString options = elemurl.GetOptions();
      // Reset options and anchor
      elemurl.SetOptions("");
      elemurl.SetAnchor("");
      // Locate the file
      TString eurl(elemurl.GetUrl());
      if (!stg || !stg->Matches(eurl)) {
         SafeDelete(stg);
         {
            TDirectory::TContext ctxt(0);
            stg = TFileStager::Open(eurl);
         }
         if (!stg) {
            Error("Lookup", "TFileStager instance cannot be instantiated");
            break;
         }
      }
      Int_t n1 = (nelements > 100) ? (Int_t) nelements / 100 : 1;
      if (stg->Locate(eurl.Data(), eurl) == 0) {
         if (nlook > 0 && !(nlook % n1)) {
            printf("Lookup | %3d %% finished\r", 100 * nlook / nelements);
            fflush(stdout);
         }
         // Get the effective end-point Url
         elemurl.SetUrl(eurl);
         // Restore original options and anchor, if any
         elemurl.SetOptions(options);
         elemurl.SetAnchor(anchor);
         // Save it into the element
         element->SetTitle(elemurl.GetUrl());
         // Remember
         element->SetLookedUp();
      } else {
         // Failure: remove
         fFiles->Remove(element);
         if (gSystem->AccessPathName(eurl))
            Error("Lookup", "file %s does not exist\n", eurl.Data());
         else
            Error("Lookup", "file %s cannot be read\n", eurl.Data());
      }
   }
   if (nelements > 0)
      printf("Lookup | %3d %% finished\n", 100 * nlook / nelements);
   else
      printf("\n");
   fflush(stdout);
   SafeDelete(stg);
}

//______________________________________________________________________________
void TChain::Loop(Option_t* option, Long64_t nentries, Long64_t firstentry)
{
   // -- Loop on nentries of this chain starting at firstentry.  (NOT IMPLEMENTED)

   Error("Loop", "Function not yet implemented");

   if (option || nentries || firstentry) { }  // keep warnings away

#if 0
   if (LoadTree(firstentry) < 0) return;

   if (firstentry < 0) firstentry = 0;
   Long64_t lastentry = firstentry + nentries -1;
   if (lastentry > fEntries-1) {
      lastentry = fEntries -1;
   }

   GetPlayer();
   GetSelector();
   fSelector->Start(option);

   Long64_t entry = firstentry;
   Int_t tree,e0,en;
   for (tree=0;tree<fNtrees;tree++) {
      e0 = fTreeOffset[tree];
      en = fTreeOffset[tree+1] - 1;
      if (en > lastentry) en = lastentry;
      if (entry > en) continue;

      LoadTree(entry);
      fSelector->BeginFile();

      while (entry <= en) {
         fSelector->Execute(fTree, entry - e0);
         entry++;
      }
      fSelector->EndFile();
   }

   fSelector->Finish(option);
#endif
}

//______________________________________________________________________________
void TChain::ls(Option_t* option) const
{
   // -- List the chain.
   TIter next(fFiles);
   TChainElement* file = 0;
   while ((file = (TChainElement*)next())) {
      file->ls(option);
   }
}

//______________________________________________________________________________
Long64_t TChain::Merge(const char* name, Option_t* option)
{
   // Merge all the entries in the chain into a new tree in a new file.
   //
   // See important note in the following function Merge().
   //
   // If the chain is expecting the input tree inside a directory,
   // this directory is NOT created by this routine.
   //
   // So in a case where we have:
   //
   //      TChain ch("mydir/mytree");
   //      ch.Merge("newfile.root");
   //
   // The resulting file will have not subdirectory. To recreate
   // the directory structure do:
   //
   //      TFile* file = TFile::Open("newfile.root", "RECREATE");
   //      file->mkdir("mydir")->cd();
   //      ch.Merge(file);
   //

   TFile *file = TFile::Open(name, "recreate", "chain files", 1);
   return Merge(file, 0, option);
}

//______________________________________________________________________________
Long64_t TChain::Merge(TCollection* /* list */, Option_t* /* option */ )
{
   // Merge all chains in the collection.  (NOT IMPLEMENTED)

   Error("Merge", "not implemented");
   return -1;
}

//______________________________________________________________________________
Long64_t TChain::Merge(TFile* file, Int_t basketsize, Option_t* option)
{
   // Merge all the entries in the chain into a new tree in the current file.
   //
   // Note: The "file" parameter is *not* the file where the new
   //       tree will be inserted.  The new tree is inserted into
   //       gDirectory, which is usually the most recently opened
   //       file, or the directory most recently cd()'d to.
   //
   // If option = "C" is given, the compression level for all branches
   // in the new Tree is set to the file compression level.  By default,
   // the compression level of all branches is the original compression
   // level in the old trees.
   //
   // If basketsize > 1000, the basket size for all branches of the
   // new tree will be set to basketsize.
   //
   // Example using the file generated in $ROOTSYS/test/Event
   // merge two copies of Event.root
   //
   //        gSystem.Load("libEvent");
   //        TChain ch("T");
   //        ch.Add("Event1.root");
   //        ch.Add("Event2.root");
   //        ch.Merge("all.root");
   //
   // If the chain is expecting the input tree inside a directory,
   // this directory is NOT created by this routine.
   //
   // So if you do:
   //
   //      TChain ch("mydir/mytree");
   //      ch.Merge("newfile.root");
   //
   // The resulting file will not have subdirectories.  In order to
   // preserve the directory structure do the following instead:
   //
   //      TFile* file = TFile::Open("newfile.root", "RECREATE");
   //      file->mkdir("mydir")->cd();
   //      ch.Merge(file);
   //
   // If 'option' contains the word 'fast' the merge 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 is 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 basket are sorted on their offset in the original
   // file; Usually this also means that the baskets are sorted
   // on 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 on 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.
   //
   // IMPORTANT Note 1: AUTOMATIC FILE OVERFLOW
   // -----------------------------------------
   // When merging many files, it may happen that the resulting file
   // reaches a size > TTree::fgMaxTreeSize (default = 1.9 GBytes).
   // In this case the current file is automatically closed and a new
   // file started.  If the name of the merged file was "merged.root",
   // the subsequent files will be named "merged_1.root", "merged_2.root",
   // etc.  fgMaxTreeSize may be modified via the static function
   // TTree::SetMaxTreeSize.
   // When in fast mode, the check and switch is only done in between each
   // input file.
   //
   // IMPORTANT Note 2: The output file is automatically closed and deleted.
   // ----------------------------------------------------------------------
   // This is required because in general the automatic file overflow described
   // above may happen during the merge.
   // If only the current file is produced (the file passed as first argument),
   // one can instruct Merge to not close and delete the file by specifying
   // the option "keep".
   //
   // The function returns the total number of files produced.
   // To check that all files have been merged use something like:
   //    if (newchain->GetEntries()!=oldchain->GetEntries()) {
   //      ... not all the file have been copied ...
   //    }

   // We must have been passed a file, we will use it
   // later to reset the compression level of the branches.
   if (!file) {
      // FIXME: We need an error message here.
      return 0;
   }

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

   // The chain tree must have a list of branches
   // because we may try to change their basket
   // size later.
   TObjArray* lbranches = GetListOfBranches();
   if (!lbranches) {
      // FIXME: We need an error message here.
      return 0;
   }

   // The chain must have a current tree because
   // that is the one we will clone.
   if (!fTree) {
      // -- LoadTree() has not yet been called, no current tree.
      // FIXME: We need an error message here.
      return 0;
   }

   // Copy the chain's current tree without
   // copying any entries, we will do that later.
   TTree* newTree = CloneTree(0);
   if (!newTree) {
      // FIXME: We need an error message here.
      return 0;
   }

   // Strip out the (potential) directory name.
   // FIXME: The merged chain may or may not have the
   //        same name as the original chain.  This is
   //        bad because the chain name determines the
   //        names of the trees in the chain by default.
   newTree->SetName(gSystem->BaseName(GetName()));

   // FIXME: Why do we do this?
   newTree->SetAutoSave(2000000000);

   // Circularity is incompatible with merging, it may
   // force us to throw away entries, which is not what
   // we are supposed to do.
   newTree->SetCircular(0);

   // Reset the compression level of the branches.
   if (opt.Contains("c")) {
      TBranch* branch = 0;
      TIter nextb(newTree->GetListOfBranches());
      while ((branch = (TBranch*) nextb())) {
         branch->SetCompressionLevel(file->GetCompressionLevel());
      }
   }

   // Reset the basket size of the branches.
   if (basketsize > 1000) {
      TBranch* branch = 0;
      TIter nextb(newTree->GetListOfBranches());
      while ((branch = (TBranch*) nextb())) {
         branch->SetBasketSize(basketsize);
      }
   }

   Long64_t nentries = GetEntriesFast();

   // Copy the entries.
   if (fastClone) {
      // For each tree in the chain.
      for (Long64_t i = 0; i < nentries; i += GetTree()->GetEntries()) {
         if (LoadTree(i) < 0) {
            break;
         }
         if (newTree->GetDirectory()) {
            TFile* file2 = newTree->GetDirectory()->GetFile();
            if (file2 && (file2->GetEND() > TTree::GetMaxTreeSize())) {
               if (newTree->GetDirectory() == (TDirectory*) file2) {
                  newTree->ChangeFile(file2);
               }
            }
         }
         TTreeCloner cloner(GetTree(), newTree, option, TTreeCloner::kNoWarnings);
         if (cloner.IsValid()) {
            newTree->SetEntries(newTree->GetEntries() + GetTree()->GetEntries());
            cloner.Exec();
            if (i!=0 && newTree->GetTreeIndex()) {
               newTree->GetTreeIndex()->Append(GetTree()->GetTreeIndex(),kTRUE);
            }
         } else {
            if (cloner.NeedConversion()) {
               TTree *localtree = GetTree();
               Long64_t tentries = localtree->GetEntries();
               for (Long64_t ii = 0; ii < tentries; ii++) {
                  if (localtree->GetEntry(ii) <= 0) {
                     break;
                  }
                  newTree->Fill();
               }
               if (newTree->GetTreeIndex()) {
                  newTree->GetTreeIndex()->Append(GetTree()->GetTreeIndex(), kTRUE);
               }
            } else {
               Warning("Merge",cloner.GetWarning());
               if (GetFile()) {
                  Warning("Merge", "Skipped file %s\n", GetFile()->GetName());
               } else {
                  Warning("Merge", "Skipped file number %d\n", fTreeNumber);
               }
            }
         }
      }
      if (newTree->GetTreeIndex()) {
         newTree->GetTreeIndex()->Append(0,kFALSE); // Force the sorting
      }
   } else {
      Int_t treenumber = 0;
      for (Long64_t i = 0; i < nentries; i++) {
         if (GetEntry(i) <= 0) {
            break;
         }
         newTree->Fill();
         if (treenumber != GetTreeNumber()) {
            if (newTree->GetTreeIndex()) {
               newTree->GetTreeIndex()->Append(GetTree()->GetTreeIndex(),kTRUE);
            }
            treenumber = GetTreeNumber();
         }
      }
      if (newTree->GetTreeIndex()) {
         newTree->GetTreeIndex()->Append(0,kFALSE); // Force the sorting
      }
   }

   // Write the new tree header.
   newTree->Write();

   // Get our return value.
   Int_t nfiles = newTree->GetFileNumber() + 1;

   // Close and delete the current file of the new tree.
   if (!opt.Contains("keep")) {
      // FIXME: What happens to fDirectory in newTree here?
      delete newTree->GetCurrentFile();
   }
   return nfiles;
}

//______________________________________________________________________________
void TChain::Print(Option_t *option) const
{
   // -- Print the header information of each tree in the chain.
   // See TTree::Print for a list of options.

   TIter next(fFiles);
   TChainElement *element;
   while ((element = (TChainElement*)next())) {
      TFile *file = TFile::Open(element->GetTitle());
      if (file && !file->IsZombie()) {
         TTree *tree = (TTree*)file->Get(element->GetName());
         if (tree) tree->Print(option);
      }
      delete file;
   }
}

//______________________________________________________________________________
Long64_t TChain::Process(const char *filename, Option_t *option, Long64_t nentries, Long64_t firstentry)
{
   // Process all entries in this chain, calling functions in filename.
   // The return value is -1 in case of error and TSelector::GetStatus() in
   // in case of success.
   // See TTree::Process.

   if (fProofChain) {
      // Make sure the element list is uptodate
      if (!TestBit(kProofUptodate))
         SetProof(kTRUE, kTRUE);
      fProofChain->SetEventList(fEventList);
      fProofChain->SetEntryList(fEntryList);
      return fProofChain->Process(filename, option, nentries, firstentry);
   }

   if (LoadTree(firstentry) < 0) {
      return 0;
   }
   return TTree::Process(filename, option, nentries, firstentry);
}

//______________________________________________________________________________
Long64_t TChain::Process(TSelector* selector, Option_t* option, Long64_t nentries, Long64_t firstentry)
{
   // Process this chain executing the code in selector.
   // The return value is -1 in case of error and TSelector::GetStatus() in
   // in case of success.

   if (fProofChain) {
      // Make sure the element list is uptodate
      if (!TestBit(kProofUptodate))
         SetProof(kTRUE, kTRUE);
      fProofChain->SetEventList(fEventList);
      fProofChain->SetEntryList(fEntryList);
      return fProofChain->Process(selector, option, nentries, firstentry);
   }

   return TTree::Process(selector, option, nentries, firstentry);
}

//______________________________________________________________________________
void TChain::Reset(Option_t*)
{
   // -- Resets the state of this chain.

   delete fFile;
   fFile = 0;
   fNtrees         = 0;
   fTreeNumber     = -1;
   fTree           = 0;
   fFile           = 0;
   fFiles->Delete();
   fStatus->Delete();
   fTreeOffset[0]  = 0;
   TChainElement* element = new TChainElement("*", "");
   fStatus->Add(element);
   fDirectory = 0;

   TTree::Reset();
}

//_______________________________________________________________________
Long64_t TChain::Scan(const char* varexp, const char* selection, Option_t* option, Long64_t nentries, Long64_t firstentry)
{
   // -- Loop on tree 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.

   if (LoadTree(firstentry) < 0) {
      return 0;
   }
   return TTree::Scan(varexp, selection, option, nentries, firstentry);
}

//_______________________________________________________________________
void TChain::SetAutoDelete(Bool_t autodelete)
{
   // -- Set the global branch kAutoDelete bit.
   //
   //  When LoadTree loads a new Tree, the branches for which
   //  the address is set will have the option AutoDelete set
   //  For more details on AutoDelete, see TBranch::SetAutoDelete.

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

//______________________________________________________________________________
void TChain::ResetBranchAddress(TBranch *branch)
{
   // -- Reset the addresses of the branch.

   if (fTree) {
      fTree->ResetBranchAddress(branch);
   }
}

//______________________________________________________________________________
void TChain::ResetBranchAddresses()
{
   // -- Reset the addresses of the branches.

   TIter next(fStatus);
   TChainElement* element = 0;
   while ((element = (TChainElement*) next())) {
      element->SetBaddress(0);
   }
   if (fTree) {
      fTree->ResetBranchAddresses();
   }
}

//_______________________________________________________________________
void TChain::SetBranchAddress(const char *bname, void* add, TBranch** ptr)
{
   // -- Set branch address.
   //
   //      bname is the name of a branch.
   //      add is the address of the branch.
   //
   //    Note: See the comments in TBranchElement::SetAddress() for a more
   //          detailed discussion of the meaning of the add parameter.
   //
   // IMPORTANT REMARK:
   // In case TChain::SetBranchStatus is called, it must be called
   // BEFORE calling this function.
   //

   // Check if bname is already in the status list.
   // If not, create a TChainElement object and set its address.
   TChainElement* element = (TChainElement*) fStatus->FindObject(bname);
   if (!element) {
      element = new TChainElement(bname, "");
      fStatus->Add(element);
   }
   element->SetBaddress(add);
   element->SetBranchPtr(ptr);
   // Also set address in current tree.
   // FIXME: What about the chain clones?
   if (fTreeNumber >= 0) {
      TBranch* branch = fTree->GetBranch(bname);
      if (ptr) {
         *ptr = branch;
      }
      if (branch) {
         CheckBranchAddressType(branch, TClass::GetClass(element->GetBaddressClassName()), (EDataType) element->GetBaddressType(), element->GetBaddressIsPtr());
         if (fClones) {
            void* oldAdd = branch->GetAddress();
            for (TObjLink* lnk = fClones->FirstLink(); lnk; lnk = lnk->Next()) {
               TTree* clone = (TTree*) lnk->GetObject();
               TBranch* cloneBr = clone->GetBranch(bname);
               if (cloneBr && (cloneBr->GetAddress() == oldAdd)) {
                  // the clone's branch is still pointing to us
                  cloneBr->SetAddress(add);
               }
            }
         }
         branch->SetAddress(add);
      }
   } else {
      if (ptr) {
         *ptr = 0;
      }
   }
}

//_______________________________________________________________________
void TChain::SetBranchAddress(const char* bname, void* add, TClass* realClass, EDataType datatype, Bool_t isptr)
{
   // Check if bname is already in the status list, and if not, create a TChainElement object and set its address.
   //
   //    Note: See the comments in TBranchElement::SetAddress() for a more
   //          detailed discussion of the meaning of the add parameter.
   //
   return SetBranchAddress(bname, add, 0, realClass, datatype, isptr);
}

//_______________________________________________________________________
void TChain::SetBranchAddress(const char* bname, void* add, TBranch** ptr, TClass* realClass, EDataType datatype, Bool_t isptr)
{
   // Check if bname is already in the status list, and if not, create a TChainElement object and set its address.
   //
   //    Note: See the comments in TBranchElement::SetAddress() for a more
   //          detailed discussion of the meaning of the add parameter.
   //

   TChainElement* element = (TChainElement*) fStatus->FindObject(bname);
   if (!element) {
      element = new TChainElement(bname, "");
      fStatus->Add(element);
   }
   if (realClass) {
      element->SetBaddressClassName(realClass->GetName());
   }
   element->SetBaddressType((UInt_t) datatype);
   element->SetBaddressIsPtr(isptr);
   element->SetBranchPtr(ptr);
   SetBranchAddress(bname, add, ptr);
}

//_______________________________________________________________________
void TChain::SetBranchStatus(const char* bname, Bool_t status, UInt_t* found)
{
   // -- Set branch status to Process or DoNotProcess
   //
   //      bname is the name of a branch. if bname="*", apply to all branches.
   //      status = 1  branch will be processed
   //             = 0  branch will not be processed
   //  See IMPORTANT REMARKS in TTree::SetBranchStatus and TChain::SetBranchAddress
   //
   //  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.

   // FIXME: We never explicitly set found to zero!

   // Check if bname is already in the status list,
   // if not create a TChainElement object and set its status.
   TChainElement* element = (TChainElement*) fStatus->FindObject(bname);
   if (element) {
      fStatus->Remove(element);
   } else {
      element = new TChainElement(bname, "");
   }
   fStatus->Add(element);
   element->SetStatus(status);
   // Also set status in current tree.
   if (fTreeNumber >= 0) {
      fTree->SetBranchStatus(bname, status, found);
   } else if (found) {
      *found = 1;
   }
}

//______________________________________________________________________________
void TChain::SetDirectory(TDirectory* dir)
{
   // Remove reference to this chain from current directory and add
   // reference to new directory dir. dir can be 0 in which case the chain
   // does not belong to any directory.

   if (fDirectory == dir) return;
   if (fDirectory) fDirectory->Remove(this);
   fDirectory = dir;
   if (fDirectory) {
      fDirectory->Append(this);
      fFile = fDirectory->GetFile();
   } else {
      fFile = 0;
   }
}

//_______________________________________________________________________
void TChain::SetEntryList(TEntryList *elist, Option_t *opt)
{
   //Set the input entry list (processing the entries of the chain will then be
   //limited to the entries in the list)
   //This function finds correspondance between the sub-lists of the TEntryList
   //and the trees of the TChain
   //By default (opt=""), both the file names of the chain elements and
   //the file names of the TEntryList sublists are expanded to full path name.
   //If opt = "ne", the file names are taken as they are and not expanded

   if (fEntryList){
      //check, if the chain is the owner of the previous entry list
      //(it happens, if the previous entry list was created from a user-defined
      //TEventList in SetEventList() function)
      if (fEntryList->TestBit(kCanDelete)) {
         TEntryList *tmp = fEntryList;
         fEntryList = 0; // Avoid problem with RecursiveRemove.
         delete tmp;
      } else {
         fEntryList = 0;
      }
   }
   if (!elist){
      fEntryList = 0;
      fEventList = 0;
      return;
   }
   if (!elist->TestBit(kCanDelete)){
      //this is a direct call to SetEntryList, not via SetEventList
      fEventList = 0;
   }
   if (elist->GetN() == 0){
      fEntryList = elist;
      return;
   }
   if (fProofChain){
      //for processing on proof, event list and entry list can't be
      //set at the same time.
      fEventList = 0;
      fEntryList = elist;
      return;
   }

   Int_t ne = fFiles->GetEntries();
   Int_t listfound=0;
   TString treename, filename;

   TEntryList *templist = 0;
   for (Int_t ie = 0; ie<ne; ie++){
      treename =((TChainElement*)fFiles->UncheckedAt(ie))->GetName();
      filename = ((TChainElement*)fFiles->UncheckedAt(ie))->GetTitle();
      templist = elist->GetEntryList(treename.Data(), filename.Data(), opt);
      if (templist) {
         listfound++;
         templist->SetTreeNumber(ie);
      }
   }

   if (listfound == 0){
      Error("SetEntryList", "No list found for the trees in this chain");
      fEntryList = 0;
      return;
   }
   fEntryList = elist;
   TList *elists = elist->GetLists();
   Bool_t shift = kFALSE;
   TIter next(elists);

   //check, if there are sub-lists in the entry list, that don't
   //correspond to any trees in the chain
   while((templist = (TEntryList*)next())){
      if (templist->GetTreeNumber() < 0){
         shift = kTRUE;
         break;
      }
   }
   fEntryList->SetShift(shift);

}

//_______________________________________________________________________
void TChain::SetEntryListFile(const char *filename, Option_t * /*opt*/)
{
// Set the input entry list (processing the entries of the chain will then be
// limited to the entries in the list). This function creates a special kind
// of entry list (TEntryListFromFile object) that loads lists, corresponding
// to the chain elements, one by one, so that only one list is in memory at a time.
//
// If there is an error opening one of the files, this file is skipped and the
// next file is loaded
//
// File naming convention:
// - by default, filename_elist.root is used, where filename is the
//   name of the chain element
// - xxx$xxx.root - $ sign is replaced by the name of the chain element
// If the list name is not specified (by passing filename_elist.root/listname to
// the TChain::SetEntryList() function, the first object of class TEntryList
// in the file is taken.
//
// It is assumed, that there are as many list files, as there are elements in
// the chain and they are in the same order


   if (fEntryList){
      //check, if the chain is the owner of the previous entry list
      //(it happens, if the previous entry list was created from a user-defined
      //TEventList in SetEventList() function)
      if (fEntryList->TestBit(kCanDelete)) {
         TEntryList *tmp = fEntryList;
         fEntryList = 0; // Avoid problem with RecursiveRemove.
         delete tmp;
      } else {
         fEntryList = 0;
      }
   }

   fEventList = 0;

   TString basename(filename);

   Int_t dotslashpos = basename.Index(".root/");
   TString behind_dot_root = "";
   if (dotslashpos>=0) {
      // Copy the list name specification
      behind_dot_root = basename(dotslashpos+6,basename.Length()-dotslashpos+6);
      // and remove it from basename
      basename.Remove(dotslashpos+5);
   }
   fEntryList = new TEntryListFromFile(basename.Data(), behind_dot_root.Data(), fNtrees);
   fEntryList->SetBit(kCanDelete, kTRUE);
   fEntryList->SetDirectory(0);
   ((TEntryListFromFile*)fEntryList)->SetFileNames(fFiles);
}


//_______________________________________________________________________
void TChain::SetEventList(TEventList *evlist)
{
//This function transfroms the given TEventList into a TEntryList
//
//NOTE, that this function loads all tree headers, because the entry numbers
//in the TEventList are global and have to be recomputed, taking into account
//the number of entries in each tree.
//
//The new TEntryList is owned by the TChain and gets deleted when the chain
//is deleted. This TEntryList is returned by GetEntryList() function, and after
//GetEntryList() function is called, the TEntryList is not owned by the chain
//any more and will not be deleted with it.

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

   if(fProofChain) {
      //on proof, fEventList and fEntryList shouldn't be set at the same time
      if (fEntryList){
         //check, if the chain is the owner of the previous entry list
         //(it happens, if the previous entry list was created from a user-defined
         //TEventList in SetEventList() function)
         if (fEntryList->TestBit(kCanDelete)){
            TEntryList *tmp = fEntryList;
            fEntryList = 0; // Avoid problem with RecursiveRemove.
            delete tmp;
         } else {
            fEntryList = 0;
         }
      }
      return;
   }

   char enlistname[100];
   sprintf(enlistname, "%s_%s", evlist->GetName(), "entrylist");
   TEntryList *enlist = new TEntryList(enlistname, evlist->GetTitle());
   enlist->SetDirectory(0);

   Int_t nsel = evlist->GetN();
   Long64_t globalentry, localentry;
   const char *treename;
   const char *filename;
   if (fTreeOffset[fNtrees-1]==theBigNumber){
      //Load all the tree headers if the tree offsets are not known
      //It is assumed here, that loading the last tree will load all
      //previous ones
      printf("loading trees\n");
      (const_cast<TChain*>(this))->LoadTree(evlist->GetEntry(evlist->GetN()-1));
   }
   for (Int_t i=0; i<nsel; i++){
      globalentry = evlist->GetEntry(i);
      //add some protection from globalentry<0 here
      Int_t treenum = 0;
      while (globalentry>=fTreeOffset[treenum])
         treenum++;
      treenum--;
      localentry = globalentry - fTreeOffset[treenum];
      // printf("globalentry=%lld, treeoffset=%lld, localentry=%lld\n", globalentry, fTreeOffset[treenum], localentry);
      treename = ((TNamed*)fFiles->At(treenum))->GetName();
      filename = ((TNamed*)fFiles->At(treenum))->GetTitle();
      //printf("entering for tree %s %s\n", treename, filename);
      enlist->SetTree(treename, filename);
      enlist->Enter(localentry);
   }
   enlist->SetBit(kCanDelete, kTRUE);
   enlist->SetReapplyCut(evlist->GetReapplyCut());
   SetEntryList(enlist);
}

//_______________________________________________________________________
void TChain::SetPacketSize(Int_t size)
{
   // -- Set number of entries per packet for parallel root.

   fPacketSize = size;
   TIter next(fFiles);
   TChainElement *element;
   while ((element = (TChainElement*)next())) {
      element->SetPacketSize(size);
   }
}

//______________________________________________________________________________
void TChain::SetProof(Bool_t on, Bool_t refresh, Bool_t gettreeheader)
{
   // Enable/Disable PROOF processing on the current default Proof (gProof).
   //
   // "Draw" and "Processed" commands will be handled by PROOF.
   // The refresh and gettreeheader are meaningfull only if on == kTRUE.
   // If refresh is kTRUE the underlying fProofChain (chain proxy) is always
   // rebuilt (even if already existing).
   // If gettreeheader is kTRUE the header of the tree will be read from the
   // PROOF cluster: this is only needed for browsing and should be used with
   // care because it may take a long time to execute.

   if (!on) {
      // Disable
      SafeDelete(fProofChain);
      // Reset related bit
      ResetBit(kProofUptodate);
   } else {
      if (fProofChain && !refresh &&
         (!gettreeheader || (gettreeheader && fProofChain->GetTree()))) {
         return;
      }
      SafeDelete(fProofChain);
      ResetBit(kProofUptodate);

      // Make instance of TChainProof via the plugin manager
      TPluginHandler *h;
      if ((h = gROOT->GetPluginManager()->FindHandler("TChain", "proof"))) {
         if (h->LoadPlugin() == -1)
         return;
         if (!(fProofChain = reinterpret_cast<TChain *>(h->ExecPlugin(2, this, gettreeheader))))
            Error("SetProof", "creation of TProofChain failed");
         // Set related bits
         SetBit(kProofUptodate);
      }
   }
}

//______________________________________________________________________________
void TChain::SetWeight(Double_t w, Option_t* option)
{
   // -- Set chain weight.
   //
   // The weight is used by TTree::Draw to automatically weight each
   // selected entry in the resulting histogram.
   //  For example the equivalent of
   //     chain.Draw("x","w")
   //  is
   //     chain.SetWeight(w,"global");
   //     chain.Draw("x");
   //
   //  By default the weight used will be the weight
   //  of each Tree in the TChain. However, one can force the individual
   //  weights to be ignored by specifying the option "global".
   //  In this case, the TChain global weight will be used for all Trees.

   fWeight = w;
   TString opt = option;
   opt.ToLower();
   ResetBit(kGlobalWeight);
   if (opt.Contains("global")) {
      SetBit(kGlobalWeight);
   }
}

//______________________________________________________________________________
void TChain::Streamer(TBuffer& b)
{
   // -- Stream a class object.

   if (b.IsReading()) {
      UInt_t R__s, R__c;
      Version_t R__v = b.ReadVersion(&R__s, &R__c);
      if (R__v > 2) {
         b.ReadClassBuffer(TChain::Class(), this, R__v, R__s, R__c);
         return;
      }
      //====process old versions before automatic schema evolution
      TTree::Streamer(b);
      b >> fTreeOffsetLen;
      b >> fNtrees;
      fFiles->Streamer(b);
      if (R__v > 1) {
         fStatus->Streamer(b);
         fTreeOffset = new Long64_t[fTreeOffsetLen];
         b.ReadFastArray(fTreeOffset,fTreeOffsetLen);
      }
      b.CheckByteCount(R__s, R__c, TChain::IsA());
      //====end of old versions

   } else {
      b.WriteClassBuffer(TChain::Class(),this);
   }
}

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