// @(#)root/tree:$Id$
// Author: Anna Kreshuk 27/10/2006

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

//______________________________________________________________________________
/* Begin_Html
<center><h2>TEntryList: a List of entry numbers in a TTree or TChain</h2></center>

There are two types of entry lists:
<ol>
<li> for a TTree (fBlocks data member is non-zero)
  Entry numbers are stored in TEntryListBlocks, which, in their turn, are stored
  in the TObjArray fBlocks. The range of the entry numbers is cut into intervals
  of kBlockSize entries (currently 64000), so that the first block contains
  information which entries out of the first 64000 pass the selection, the second
  block - which entries out of the 64000-127999 interval pass the selection, etc.
  Some blocks, obviously, might be empty. The internal representation of entry
  numbers in the blocks is described in the TEntryListBlock class description, and
  this representation might be changed by calling OptimizeStorage() function
  (when the list is filled via the Enter() function, this is done automatically,
  except for the last block).
  Individual entry lists can be merged (functions Merge() and Add())
  to make an entry list for a TChain of corresponding TTrees.
End_Html
Begin_Macro(source)
entrylist_figure1.C
End_Macro

Begin_Html

<li> for a TChain (fLists data member is non-zero)
  It contains a TList of sub-lists (TEntryList objects, corresponding to each TTree)
  Trees and lists are matched by the TTree name and its file name (full path).
  All sub-lists are returned by the GetLists() function and individual lists are
  returned by GetEntryList() function. Such lists are no different from the lists for
  TTrees, described above.
End_Html
Begin_Macro(source)
entrylist_figure2.C
End_Macro

Begin_Html
</ol>
<h4>Operations on entry lists</h4>

<ul>
<li> <b>Add</b>() - if the lists are for the same tree, adds all the entries of the second list
          to the first list. If the lists are for different trees, creates a TEntryList
          with 2 sublists for each TTree. If the lists are for TChains, merges the ones
          for the same trees and adds new sublists for the TTrees that were not included
          in the first TEntryList
<li> <b>Subtract</b>() - if the lists are for the same TTree, removes the entries of the second
               list from the first list. If the lists are for TChains, loops over all
               sub-lists
<li> <b>GetEntry(n)</b> - returns the n-th entry number
<li> <b>Next</b>()      - returns next entry number. Note, that this function is
                much faster than GetEntry, and it's called when GetEntry() is called
                for 2 or more indices in a row.
</ul>

<h4>TTree::Draw() and TChain::Draw()</h4>

  Use option <b>entrylist</b> to write the results of TTree::Draw and TChain::Draw into
  an entry list. Example:
<pre>
     tree->Draw(">>elist", "x<0 && y>0", "entrylist");
     TEntryList *elist = (TEntryList*)gDirectory->Get("elist");
</pre>

<h4> Example of Loop on TEntryList with a TChain</h4>
<pre>
void loopChain() {
   TFile *fe = TFile::Open("myelist.root");
   TEntryList *myelist = (TEntryList*)fe-&gt;Get("myelist");
   TChain *ch = new TChain("ntuple");
   ch-&gt;Add("hsimple.root");
   ch-&gt;Add("hsimple2.root");
   Long64_t listEntries = myelist-&gt;GetN();
   Long64_t chainEntries = ch-&gt;GetEntries();
   Int_t treenum = 0;
   ch-&gt;SetEntryList(myelist);

   for (entry=start;entry &lt; end;entry++) {
      entryNumber = treechain-&gt;GetEntryNumber(entry);
      if (entryNumber &lt; 0) break;
      localEntry = fTree-&gt;LoadTree(entryNumber);
      if (localEntry &lt; 0) break;
      // then either call branch-&gt;GetEntry(localEntry);
      // or  entryNumber-&gt;GetEntry(entryNumber);
      // In the later case the LoadTree is then somewhat redudant.
   }
 }
</pre>

When using the TEntryList interface directly, you can get the 'tree number' and entry in
the current tree (i.e. value similar to the return value of LoadTree) from calling
TEntryList::GetEntryAndTree:
<pre>
    Long64_t treeEntry = myelist-&gt;GetEntryAndTree(el,treenum);
</pre>
to obtain the entry number within the chain you need to add to it the value
of
<pre>treeEntry+ch->GetTreeOffset()[treenum]</pre>
such that the loop in the previous example can also be written as:

<pre>for (Long64_t el = 0; el &lt; listEntries; el++) {
   Long64_t treeEntry = myelist-&gt;GetEntryAndTree(el,treenum);
   Long64_t chainEntry = treeEntry+ch-&gt;GetTreeOffset()[treenum];
   printf("el=%lld, treeEntry=%lld, chainEntry=%lld, treenum=%d\n", el, treeEntry, chainEntry, treenum);

   ch-&gt;LoadTree(chainEntry); // this also returns treeEntry
   needed_branch-&gt;GetEntry(treeEntry);
}
</pre>


<h4> TSelectors</h4>

  To fill an TEntryList from a TSelector correctly, one must add the TEntryList object
  to the output list of the selector (TSelector::fOutput). This is the only way to
  make the sub-lists of the TEntryList switch when the current tree of the TChain is
  changed.

<h4> Using a TEntryList as input (TTree::SetEntryList() and TChain::SetEntryList())</h4>

  while the TTree::SetEntryList() function is only setting the TTree::fEntryList
  data member, the same function in TChain also finds correspondance between
  the TTrees of this TChain and the sub-lists of this TEntryList.

<h4>TEntryList and the current directory</h4>

  TEntryList objects are automatically added to the current directory (like TTrees).
  However, in case of a TEntryList for a chain, only the top-level entry list is added,
  not the sub-lists for specific trees. Placing entry lists in the current directory
  allows calling them as a part of a TTreeFormula expression, so if the user wants
  to extract a sublist from a TChain entry list via the GetEntryList() or some other
  function, they have to add it to the current directory to be able to use it in
  TTreeFormula expressions.

<h4>TEntryList and TEventList</h4>

  TTree::SetEventList() and TChain::SetEventList() transform a TEventList into a TEntryList
  See comments to those functions for more details
End_Html */


#include "TEntryList.h"
#include "TEntryListBlock.h"
#include "TError.h"
#include "TKey.h"
#include "TTree.h"
#include "TFile.h"
#include "TRegexp.h"
#include "TSystem.h"

ClassImp(TEntryList)

//______________________________________________________________________________
TEntryList::TEntryList() : fEntriesToProcess(0)
{
   //default c-tor

   fLists = 0;
   fCurrent = 0;
   fBlocks = 0;
   fN = 0;
   fNBlocks = 0;
   fTreeName = "";
   fFileName = "";
   fStringHash = 0;
   fTreeNumber = -1;
   fDirectory = 0;
   fReapply = kFALSE;
   fLastIndexQueried = -1;
   fLastIndexReturned = 0;
   fShift = kFALSE;
}

//______________________________________________________________________________
TEntryList::TEntryList(const char *name, const char *title) :
   TNamed(name, title),
   fEntriesToProcess(0)
{
   //c-tor with name and title

   fLists = 0;
   fCurrent = 0;
   fBlocks = 0;
   fN = 0;
   fNBlocks = 0;
   fTreeName = "";
   fFileName = "";
   fStringHash = 0;
   fTreeNumber = -1;
   fReapply = kFALSE;

   fDirectory  = gDirectory;
   if (fDirectory) fDirectory->Append(this);

   fLastIndexQueried = -1;
   fLastIndexReturned = 0;
   fShift = kFALSE;
}

//______________________________________________________________________________
TEntryList::TEntryList(const char *name, const char *title, const TTree *tree):TNamed(name, title)
{
   //constructor with name and title, which also sets the tree

   fLists = 0;
   fCurrent = 0;
   fBlocks = 0;
   fN = 0;
   fNBlocks = 0;
   fTreeNumber = -1;
   TEntryList::SetTree(tree);
   fReapply = kFALSE;

   fDirectory  = gDirectory;
   if (fDirectory) fDirectory->Append(this);

   fLastIndexQueried = -1;
   fLastIndexReturned = 0;
   fShift = kFALSE;
}

//______________________________________________________________________________
TEntryList::TEntryList(const char *name, const char *title, const char *treename, const char *filename) : TNamed(name, title),fEntriesToProcess(0)
{
   //c-tor with name and title, which also sets the treename and the filename

   fLists = 0;
   fCurrent = 0;
   fBlocks = 0;
   fNBlocks = 0;
   fN = 0;
   SetTree(treename, filename);
   fTreeNumber = -1;
   fReapply = kFALSE;

   fDirectory  = gDirectory;
   if (fDirectory) fDirectory->Append(this);

   fLastIndexQueried = -1;
   fLastIndexReturned = 0;
   fShift = kFALSE;
}

//______________________________________________________________________________
TEntryList::TEntryList(const TTree *tree) : fEntriesToProcess(0)
{
   //c-tor, which sets the tree

   fLists = 0;
   fCurrent = 0;
   fBlocks = 0;
   fNBlocks = 0;
   fN = 0;

   SetTree(tree);
   fTreeNumber = -1;

   fReapply = kFALSE;
   fDirectory  = gDirectory;
   if (fDirectory) fDirectory->Append(this);

   fLastIndexQueried = -1;
   fLastIndexReturned = 0;
   fShift = kFALSE;
}

//______________________________________________________________________________
TEntryList::TEntryList(const TEntryList &elist) : TNamed(elist)
{
   //copy c-tor

   fNBlocks = elist.fNBlocks;
   fTreeName = elist.fTreeName;
   fFileName = elist.fFileName;
   fStringHash = elist.fStringHash;
   fTreeNumber = elist.fTreeNumber;
   fLastIndexQueried = -1;
   fLastIndexReturned = 0;
   fN = elist.fN;
   fShift = elist.fShift;
   fLists = 0;
   fBlocks = 0;
   fReapply = elist.fReapply;
   fCurrent = 0;
   fEntriesToProcess = elist.fEntriesToProcess;
   if (elist.fLists){
      fLists = new TList();
      TEntryList *el1 = 0;
      TEntryList *el2 = 0;
      TIter next(elist.fLists);
      while((el1 = (TEntryList*)next())){
         el2 = new TEntryList(*el1);
         if (el1==elist.fCurrent)
            fCurrent = el2;
         fLists->Add(el2);
      }
   } else {
      if (elist.fBlocks){
         TEntryListBlock *block1 = 0;
         TEntryListBlock *block2 = 0;
         //or just copy it as a TObjArray??
         fBlocks = new TObjArray();
         for (Int_t i=0; i<fNBlocks; i++){
            block1 = (TEntryListBlock*)elist.fBlocks->UncheckedAt(i);
            block2 = new TEntryListBlock(*block1);
            fBlocks->Add(block2);
         }
      }
      fCurrent = this;
   }
   fDirectory  = 0;

}


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

   if (fBlocks){
      fBlocks->Delete();
      delete fBlocks;
   }
   fBlocks = 0;
   if (fLists){
      fLists->Delete();
      delete fLists;
   }

   fLists = 0;

   if (fDirectory) fDirectory->Remove(this);
   fDirectory  = 0;

}

//______________________________________________________________________________
void TEntryList::Add(const TEntryList *elist)
{
   //Add 2 entry lists

   if (fN==0){
      if (!fLists && fTreeName=="" && fFileName==""){
         //this list is empty. copy the other list completely
         fNBlocks = elist->fNBlocks;
         fTreeName = elist->fTreeName;
         fFileName = elist->fFileName;
         fStringHash = elist->fStringHash;
         fTreeNumber = elist->fTreeNumber;
         fLastIndexQueried = -1;
         fLastIndexReturned = 0;
         fN = elist->fN;
         if (elist->fLists){
            fLists = new TList();
            TEntryList *el1 = 0;
            TEntryList *el2 = 0;
            TIter next(elist->fLists);
            while((el1 = (TEntryList*)next())){
               el2 = new TEntryList(*el1);
               if (el1==elist->fCurrent)
                  fCurrent = el2;
               fLists->Add(el2);
            }
         } else {
            if (elist->fBlocks){
               TEntryListBlock *block1 = 0;
               TEntryListBlock *block2 = 0;
               fBlocks = new TObjArray();
               for (Int_t i=0; i<fNBlocks; i++){
                  block1 = (TEntryListBlock*)elist->fBlocks->UncheckedAt(i);
                  block2 = new TEntryListBlock(*block1);
                  fBlocks->Add(block2);
               }
            }
            fCurrent = 0;
         }
         return;
      }
   }

   if (!fLists){
      if (!elist->fLists){
         if (!strcmp(elist->fTreeName.Data(),fTreeName.Data()) && !strcmp(elist->fFileName.Data(),fFileName.Data())){
            //entry lists are for the same tree
            if (!elist->fBlocks)
               //the other list is empty list
               return;
            if (!fBlocks){
               //this entry list is empty
               TEntryListBlock *block1 = 0;
               TEntryListBlock *block2 = 0;
               fNBlocks = elist->fNBlocks;
               fN = elist->fN;
               fBlocks = new TObjArray();
               for (Int_t i=0; i<fNBlocks; i++){
                  block1 = (TEntryListBlock*)elist->fBlocks->UncheckedAt(i);
                  block2 = new TEntryListBlock(*block1);
               fBlocks->Add(block2);
               }
               return;
            }
            //both not empty, merge block by block
            TEntryListBlock *block1=0;
            TEntryListBlock *block2=0;
            Int_t i;
            Int_t nmin = TMath::Min(fNBlocks, elist->fNBlocks);
            Long64_t nnew, nold;
            for (i=0; i<nmin; i++){
               block1 = (TEntryListBlock*)fBlocks->UncheckedAt(i);
               block2 = (TEntryListBlock*)elist->fBlocks->UncheckedAt(i);
               nold = block1->GetNPassed();
               nnew = block1->Merge(block2);
               fN = fN - nold + nnew;
            }
            if (fNBlocks<elist->fNBlocks){
               Int_t nmax = elist->fNBlocks;
               for (i=nmin; i<nmax; i++){
                  block2 = (TEntryListBlock*)elist->fBlocks->UncheckedAt(i);
                  block1 = new TEntryListBlock(*block2);
                  fBlocks->Add(block1);
                  fN+=block1->GetNPassed();
                  fNBlocks++;
               }
            }
            fLastIndexQueried = -1;
            fLastIndexReturned = 0;
         } else {
            //entry lists are for different trees. create a chain entry list with
            //2 sub lists for the first and second entry lists
            fLastIndexQueried = -1;
            fLastIndexReturned = 0;
            fLists = new TList();
            TEntryList *el = new TEntryList();
            el->fTreeName = fTreeName;
            el->fFileName = fFileName;
            el->fBlocks = fBlocks;
            fBlocks = 0;
            el->fNBlocks = fNBlocks;
            el->fN = fN;
            el->fLastIndexQueried = -1;
            el->fLastIndexReturned = 0;
            fLists->Add(el);
            el = new TEntryList(*elist);
            el->fLastIndexQueried = -1;
            el->fLastIndexReturned = 0;
            fLists->Add(el);
            fN+=el->GetN();
            fCurrent = 0;
         }
      } else {
         //second list already has sublists. add one by one
         TEntryList *el = 0;
         TIter next(elist->fLists);
         while ((el = (TEntryList*)next())){
            Add(el);
         }
         fCurrent = 0;
      }
   } else {
      //there are already some sublists in this list, just add another one
      if (!elist->fLists){
         //the other list doesn't have sublists
         TIter next(fLists);
         TEntryList *el = 0;
         Bool_t found = kFALSE;
         while ((el = (TEntryList*)next())){
            if (!strcmp(el->fTreeName.Data(), elist->fTreeName.Data()) &&
                !strcmp(el->fFileName.Data(), elist->fFileName.Data())){
            // if (el->fStringHash == elist->fStringHash){
               //found a list for the same tree
               Long64_t oldn = el->GetN();
               el->Add(elist);
               found = kTRUE;
               fN = fN - oldn + el->GetN();
               break;
            }
         }
         if (!found){
            el = new TEntryList(*elist);
            el->fLastIndexQueried = -1;
            el->fLastIndexReturned = 0;
            fLists->Add(el);
            fN+=el->GetN();
         }
      } else {
         //add all sublists from the other list
         TEntryList *el = 0;
         TIter next(elist->fLists);
         while ((el = (TEntryList*)next())){
            Add(el);
         }
         fCurrent = 0;
      }
      if (fCurrent){
         if (fCurrent->fBlocks){
            Int_t currentblock = (fCurrent->fLastIndexReturned)/kBlockSize;
            TEntryListBlock *block = (TEntryListBlock*)fCurrent->fBlocks->UncheckedAt(currentblock);
            block->ResetIndices();
            fCurrent->fLastIndexReturned = 0;
            fCurrent->fLastIndexQueried = -1;
         }
      }
      fCurrent = 0;
   }

}


//______________________________________________________________________________
Int_t TEntryList::Contains(Long64_t entry, TTree *tree)
{
//When tree = 0, returns from the current list
//When tree != 0, finds the list, corresponding to this tree
//When tree is a chain, the entry is assumed to be global index and the local
//entry is recomputed from the treeoffset information of the chain

   if (!tree){
      if (fBlocks) {
         //this entry list doesn't contain any sub-lists
         TEntryListBlock *block = 0;
         Int_t nblock = entry/kBlockSize;
         if (nblock >= fNBlocks) return 0;
         block = (TEntryListBlock*)fBlocks->UncheckedAt(nblock);
         return block->Contains(entry-nblock*kBlockSize);
      }
      if (fLists) {
         if (!fCurrent) fCurrent = (TEntryList*)fLists->First();
         return fCurrent->Contains(entry);
      }
      return 0;
   } else {
      Long64_t localEntry = tree->LoadTree(entry);
      SetTree(tree->GetTree());
      if (fCurrent)
         return fCurrent->Contains(localEntry);
   }
   return 0;

}

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

   SetDirectory(dir);
}

//________________________________________________________________________
Bool_t TEntryList::Enter(Long64_t entry, TTree *tree)
{
   //Add entry #entry to the list
   //When tree = 0, adds to the current list
   //When tree != 0, finds the list, corresponding to this tree
   //When tree is a chain, the entry is assumed to be global index and the local
   //entry is recomputed from the treeoffset information of the chain

   if (!tree){
      if (!fLists) {
         if (!fBlocks) fBlocks = new TObjArray();
         TEntryListBlock *block = 0;
         Long64_t nblock = entry/kBlockSize;
         if (nblock >= fNBlocks) {
            if (fNBlocks>0){
               block = (TEntryListBlock*)fBlocks->UncheckedAt(fNBlocks-1);
               if (!block) return 0;
               block->OptimizeStorage();
            }
            for (Int_t i=fNBlocks; i<=nblock; i++){
               block = new TEntryListBlock();
               fBlocks->Add(block);
            }
         fNBlocks = nblock+1;
         }
         block = (TEntryListBlock*)fBlocks->UncheckedAt(nblock);
         if (block->Enter(entry-nblock*kBlockSize)) {
            fN++;
            return 1;
         }
      } else {
         //the entry in the current entry list
         if (!fCurrent) fCurrent = (TEntryList*)fLists->First();
         if (fCurrent->Enter(entry)) {
            if (fLists)
               fN++;
            return 1;
         }
      }
   } else {
      Long64_t localentry = tree->LoadTree(entry);
      SetTree(tree->GetTree());
      if (fCurrent){
         if (fCurrent->Enter(localentry)) {
            if (fLists)
               fN++;
            return 1;
         }
      }
   }
   return 0;

}

//______________________________________________________________________________
Bool_t TEntryList::Remove(Long64_t entry, TTree *tree)
{
//Remove entry #entry from the list
//When tree = 0, removes from the current list
//When tree != 0, finds the list, corresponding to this tree
//When tree is a chain, the entry is assumed to be global index and the local
//entry is recomputed from the treeoffset information of the chain

   if (!tree){
      if (!fLists) {
         if (!fBlocks) return 0;
         TEntryListBlock *block = 0;
         Long64_t nblock = entry/kBlockSize;
         block = (TEntryListBlock*)fBlocks->UncheckedAt(nblock);
         if (!block) return 0;
         Long64_t blockindex = entry - nblock*kBlockSize;
         if (block->Remove(blockindex)){
            fN--;
            return 1;
         }
      } else {
         if (!fCurrent) fCurrent = (TEntryList*)fLists->First();
         if (fCurrent->Remove(entry)){
            if (fLists)
               fN--;
            return 1;
         }
      }
   } else {
      Int_t localentry = tree->LoadTree(entry);
      SetTree(tree->GetTree());
      if (fCurrent){
         if (fCurrent->Remove(localentry)) {
            if (fLists)
               fN--;
            return 1;
         }
      }
   }
   return 0;
}

//______________________________________________________________________________
Long64_t TEntryList::GetEntry(Int_t index)
{
   //return the number of the entry #index of this TEntryList in the TTree or TChain
   //See also Next().


   if (index>=fN){
      return -1;
   }
   if (index==fLastIndexQueried+1){
      //in a loop
      return Next();
   } else {
      if (fBlocks) {
         TEntryListBlock *block = 0;
         Long64_t total_passed = 0;
         Int_t i=0;
         while (total_passed<=index && i<fNBlocks){
            block=(TEntryListBlock*)fBlocks->UncheckedAt(i);
            total_passed+=block->GetNPassed();
            i++;
         }
         i--;
         total_passed-=block->GetNPassed();
         if (i!=fLastIndexReturned/kBlockSize){
            block = (TEntryListBlock*)fBlocks->UncheckedAt(fLastIndexReturned/kBlockSize);
            block->ResetIndices();
            block = (TEntryListBlock*)fBlocks->UncheckedAt(i);
         }

         Long64_t localindex = index - total_passed;
         Long64_t blockindex = block->GetEntry(localindex);
         if (blockindex < 0) return -1;
         Long64_t res = i*kBlockSize + blockindex;
         fLastIndexQueried = index;
         fLastIndexReturned = res;
         return res;
      } else {
         //find the corresponding list
         if (!fCurrent) fCurrent = (TEntryList*)fLists->First();
         TIter next(fLists);
         TEntryList *templist;
         Long64_t ntotal = 0;
         if (fCurrent){
            //reset all indices of the current list
            if (fCurrent->fBlocks){
               Int_t currentblock = (fCurrent->fLastIndexReturned)/kBlockSize;
               TEntryListBlock *block = (TEntryListBlock*)fCurrent->fBlocks->UncheckedAt(currentblock);
               block->ResetIndices();
               fCurrent->fLastIndexReturned = 0;
               fCurrent->fLastIndexQueried = -1;
            }
         }
         while ((templist = (TEntryList*)next())){
            if (!fShift){
               ntotal += templist->GetN();
            } else {
               if (templist->GetTreeNumber() >= 0)
                  ntotal += templist->GetN();
            }
            if (ntotal > index)
               break;
         }
         fCurrent = templist;
         if (!fCurrent) return -1;
         Long64_t localentry = index - (ntotal - fCurrent->GetN());
         fLastIndexQueried = index;
         fLastIndexReturned = fCurrent->GetEntry(localentry);
         return fLastIndexReturned;
      }

   }
   return -1;
}

//______________________________________________________________________________
Long64_t TEntryList::GetEntryAndTree(Int_t index, Int_t &treenum)
{
//return the index of "index"-th non-zero entry in the TTree or TChain
//and the # of the corresponding tree in the chain

//If shift is true, then when the requested entry is found in an entry list,
//for which there is no corresponding tree in the chain, this list is not
//taken into account, and entry from the next list with a tree is returned.
//Example:
//First sublist - 20 entries, second sublist - 5 entries, third sublist - 10 entries
//Second sublist doesn't correspond to any trees of the chain
//Then, when GetEntryAndTree(21, treenum, kTRUE) is called, first entry of the
//third sublist will be returned

   Long64_t result = GetEntry(index);
   if (fLists)
      treenum = fCurrent->fTreeNumber;
   else
      treenum = fTreeNumber;
   if (treenum<0) return -1;

   return result;
}

//______________________________________________________________________________
void TEntryList::GetFileName(const char *filename, TString &fn, Bool_t *local)
{
   // To be able to re-localize the entry-list we identify the file by just the
   // name and the anchor, i.e. we drop protocol, host, options, ...
   // The result in the form 'file#anchor' (or 'file', if no anchor is present)
   // is saved in 'fn'.
   // The function optionally (is 'local' is defined) checks file locality (i.e.
   // protocol 'file://') returning the result in '*local' .

   TUrl u(filename, kTRUE);
   if (local) *local = (!strcmp(u.GetProtocol(), "file")) ? kTRUE : kFALSE;
   if (strlen(u.GetAnchor()) > 0) {
      fn.Form("%s#%s", u.GetFile(), u.GetAnchor());
   } else {
      fn = u.GetFile();
   }
   // Done
   return;
}

//______________________________________________________________________________
TEntryList *TEntryList::GetEntryList(const char *treename, const char *filename, Option_t *opt)
{
   //return the entry list, correspoding to treename and filename
   //By default, the filename is first tried as is, and then, if the corresponding list
   //is not found, the filename is expanded to the absolute path, and compared again.
   //To avoid it, use option "ne"

   if (gDebug > 1)
      Info("GetEntryList","tree: %s, file: %s",
                          (treename ? treename : "-"), (filename ? filename : "-"));

   if (!treename || !filename) return 0;
   TString option = opt;
   option.ToUpper();
   Bool_t nexp = option.Contains("NE");

   TString fn;
   Bool_t local;
   GetFileName(filename, fn, &local);
   if (nexp) local = kFALSE;

   if (gDebug > 1)
      Info("GetEntryList", "file: %s, local? %d", filename, local);

   if (!fLists){
      //there are no sublists
      if (!strcmp(treename, fTreeName.Data()) && !(strcmp(fn.Data(), fFileName.Data()))){
         return this;
      } else {
         //if the file is local, try the full name, unless "ne" option was specified
         if (!nexp && local){
            gSystem->ExpandPathName(fn);
            if (!gSystem->IsAbsoluteFileName(fn))
               gSystem->PrependPathName(gSystem->pwd(), fn);
            fn = gSystem->UnixPathName(fn);
            if (!strcmp(treename, fTreeName.Data()) && !(strcmp(fn.Data(), fFileName.Data())))
               return this;
         }
         return 0;
      }
   }

   TString stotal = treename;
   stotal.Append(fn);
   ULong_t newhash = stotal.Hash();

   TIter next(fLists);
   TEntryList *templist;
   while ((templist = (TEntryList*)next())){
      if (templist->fStringHash==0){
         stotal = templist->fTreeName + templist->fFileName;
         templist->fStringHash = stotal.Hash();
      }
      if (gDebug > 1)
         Info("GetEntryList", "file: %s (fn: %s), hash: %lu, element hash: %lu",
                              filename, fn.Data(), newhash, templist->fStringHash);
      if (newhash == templist->fStringHash){
         if (!strcmp(templist->GetTreeName(), treename) && !strcmp(templist->GetFileName(), fn.Data())){
            return templist;
         }
      }
   }

   //didn't find anything for this filename, try the full name too
   if (!nexp && local){
      TString longname = fn;
      gSystem->ExpandPathName(longname);
      if (!gSystem->IsAbsoluteFileName(longname))
         gSystem->PrependPathName(gSystem->pwd(), longname);
      longname = gSystem->UnixPathName(longname);
      stotal = treename;
      stotal.Append(longname);
      newhash = stotal.Hash();
      next.Reset();
      while ((templist = (TEntryList*)next())){
         if (templist->fStringHash==0){
            stotal = templist->fTreeName + templist->fFileName;
            templist->fStringHash = stotal.Hash();
         }
         if (gDebug > 1)
            Info("GetEntryList", "file: %s (longname: %s), hash: %lu, element hash: %lu",
                                 filename, longname.Data(), newhash, templist->fStringHash);
         if (newhash == templist->fStringHash){
            if (templist->fTreeName == treename && templist->fFileName == longname){
               return templist;
            }
         }
      }
   }
   return 0;
}

//______________________________________________________________________________
Int_t TEntryList::Merge(TCollection *list)
{
   //Merge this list with the lists from the collection

   if (!list) return -1;
   TIter next(list);
   TEntryList *elist = 0;
   while ((elist = (TEntryList*)next())) {
      if (!elist->InheritsFrom(TEntryList::Class())) {
         Error("Add","Attempt to add object of class: %s to a %s",elist->ClassName(),this->ClassName());
         return -1;
      }
      Add(elist);
   }
   return 0;
}

//______________________________________________________________________________
Long64_t TEntryList::Next()
{
   //return the next non-zero entry index (next after fLastIndexQueried)
   //this function is faster than GetEntry()

   Long64_t result;
   if (fN == fLastIndexQueried+1 || fN==0){
      return -1;
   }
   if (fBlocks){
      Int_t iblock = fLastIndexReturned/kBlockSize;
      TEntryListBlock *current_block = (TEntryListBlock*)fBlocks->UncheckedAt(iblock);
      result = current_block->Next();
      if (result>=0) {
         fLastIndexQueried++;
         fLastIndexReturned = result+kBlockSize*iblock;
         return fLastIndexReturned;
      }
      else {
         while (result<0 && iblock<fNBlocks-1) {
            current_block->ResetIndices();
            iblock++;
            current_block = (TEntryListBlock*)fBlocks->UncheckedAt(iblock);
            current_block->ResetIndices();
            result = current_block->Next();
         }
         if (result<0) {
            fLastIndexQueried = -1;
            fLastIndexReturned = 0;
            return -1;
         }
         fLastIndexQueried++;
         fLastIndexReturned = result+kBlockSize*iblock;

         return fLastIndexReturned;
      }
   } else {
      if (!fCurrent) {
         fCurrent = (TEntryList*)fLists->First();
         if (!fCurrent) return 0;
         if (fShift) {
            while (fCurrent->GetTreeNumber()<0) {
               fCurrent = (TEntryList*)fLists->After(fCurrent);
               if (!fCurrent) return 0;
            }
         }
      }
      result = fCurrent->Next();
      if (result>=0) {
         fLastIndexQueried++;
         fLastIndexReturned = result;
         return result;
      } else {
         if (fCurrent){
            //reset all indices of the current list
            if (fCurrent->fBlocks){
               Int_t currentblock = (fCurrent->fLastIndexReturned)/kBlockSize;
               TEntryListBlock *block = (TEntryListBlock*)fCurrent->fBlocks->UncheckedAt(currentblock);
               block->ResetIndices();
               fCurrent->fLastIndexReturned = 0;
               fCurrent->fLastIndexQueried = -1;
            }
         }

         //find the list with the next non-zero entry
         while (result<0 && fCurrent!=((TEntryList*)fLists->Last())){
            if (!fCurrent) return 0;
            fCurrent->fLastIndexQueried = -1;
            fCurrent->fLastIndexReturned = 0;
            fCurrent = (TEntryList*)fLists->After(fCurrent);
            // fCurrent is guarantee to be non-zero because it is not the 'last'
            // element of the list.
            if (!fCurrent) return 0;
            if (!fShift)
               result = fCurrent->Next();
            else {
               if (fCurrent->GetTreeNumber() >= 0)
                  result = fCurrent->Next();
            }
         }
         fLastIndexQueried++;
         fLastIndexReturned = result;
         return result;
      }
   }
}


//______________________________________________________________________________
void TEntryList::OptimizeStorage()
{
   //Checks if the array representation is more economical and if so, switches to it

   if (fBlocks){
      TEntryListBlock *block = 0;
      for (Int_t i=0; i<fNBlocks; i++){
         block = (TEntryListBlock*)fBlocks->UncheckedAt(i);
         block->OptimizeStorage();
      }
   }
}


//______________________________________________________________________________
void TEntryList::Print(const Option_t* option) const
{
   //Print this list
   //option = "" - default - print the name of the tree and file
   //option = "all" - print all the entry numbers

   TString opt = option;
   opt.ToUpper();
   if (fBlocks) {
      Printf("%s %s %lld", fTreeName.Data(), fFileName.Data(), fN);
      if (opt.Contains("A")){
         TEntryListBlock* block = 0;
         for (Int_t i=0; i<fNBlocks; i++){
            block = (TEntryListBlock*)fBlocks->UncheckedAt(i);
            Int_t shift = i*kBlockSize;
            block->PrintWithShift(shift);
         }
      }
   }
   else {
      TEntryList *elist = 0;
      if (fN>0){
         TIter next(fLists);
         while((elist = (TEntryList*)next())){
            elist->Print(option);
         }
      } else {
         if (!fLists) Printf("%s %s %lld", fTreeName.Data(), fFileName.Data(), fN);
         else {
            TIter next(fLists);
            while ((elist = (TEntryList*)next())){
               Printf("%s %s %lld", elist->GetTreeName(), elist->GetFileName(), elist->GetN());
            }
         }
      }
   }
}

//______________________________________________________________________________
void TEntryList::Reset()
{
   //Reset this list

   //Maybe not delete, but just reset the number of blocks to 0????

   if (fBlocks){
      fBlocks->Delete();
      delete fBlocks;
      fBlocks = 0;
   }
   if (fLists){
      if (!((TEntryList*)fLists->First())->GetDirectory()){
         fLists->Delete();
      }
      delete fLists;
      fLists = 0;
   }
   fCurrent = 0;
   fBlocks = 0;
   fNBlocks = 0;
   fN = 0;
   fTreeName = "";
   fFileName = "";
   fStringHash = 0;
   fTreeNumber = -1;
   fLastIndexQueried = -1;
   fLastIndexReturned = 0;
   fReapply = kFALSE;
}

//______________________________________________________________________________
void TEntryList::SetDirectory(TDirectory *dir)
{
   //Add reference to directory dir. dir can be 0.

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

//______________________________________________________________________________
void TEntryList::SetTree(const char *treename, const char *filename)
{
   //If a list for a tree with such name and filename exists, sets it as the current sublist
   //If not, creates this list and sets it as the current sublist
   //
   // ! the filename is taken as provided, no extensions to full path or url !

   TEntryList *elist = 0;

   TString fn;
   GetFileName(filename, fn);

   TString stotal = treename;
   stotal.Append(fn.Data());
   //printf("setting tree %s\n", stotal.Data());
   ULong_t newhash = stotal.Hash();
   if (fLists) {
      //find the corresponding entry list and make it current
      if (!fCurrent) fCurrent = (TEntryList*)fLists->First();
      if (fCurrent->fStringHash == 0){
         stotal = fCurrent->fTreeName + fCurrent->fFileName;
         fCurrent->fStringHash = stotal.Hash();
      }
      if (newhash == fCurrent->fStringHash){
         //this list is current
         if (!strcmp(fCurrent->fTreeName, treename) && !strcmp(fCurrent->fFileName, fn.Data())){
            return;
         }
      }
      TIter next(fLists);
      while ((elist = (TEntryList*)next())){
         if (newhash == elist->fStringHash){
            if (elist->fTreeName == treename && elist->fFileName == fn.Data()) {
               //the current entry list was changed. reset the fLastIndexQueried,
               //so that Next() doesn't start with the wrong current list
               //Also, reset those indices in the previously current list
               if (fCurrent->fBlocks){
                  Int_t currentblock = (fCurrent->fLastIndexReturned)/kBlockSize;
                  TEntryListBlock *block = (TEntryListBlock*)fCurrent->fBlocks->UncheckedAt(currentblock);
                  block->ResetIndices();
                  fCurrent->fLastIndexReturned = 0;
                  fCurrent->fLastIndexQueried = -1;
               }
               fCurrent = elist;
               fLastIndexQueried = -3;
               return;
            }
         }
      }
      //didn't find an entry list for this tree, create a new one
      elist = new TEntryList("", "", treename, fn.Data());
      if (elist->GetDirectory()) {
         //sub lists are not added to the current directory
         elist->GetDirectory()->Remove(elist);
         elist->SetDirectory(0);
      }
      fLists->Add(elist);
      fCurrent = elist;
      return;
   } else {
      if (fN==0 && fTreeName=="" && fFileName==""){
         //this is the first tree set to this list
         fTreeName = treename;
         fFileName = fn;
         stotal = fTreeName + fFileName;
         //fStringHash = stotal.Hash();
         fStringHash = newhash;
         fCurrent = this;
      } else {
         if (fStringHash == 0){
            stotal = fTreeName + fFileName;
            fStringHash = stotal.Hash();
         }
         if (newhash != fStringHash){
            //we have a chain and already have an entry list for the first tree
            //move the first entry list to the fLists
            fLists = new TList();
            elist = new TEntryList();
            elist->fTreeName = fTreeName;
            elist->fFileName = fFileName;
            elist->fStringHash = fStringHash;
            elist->fN = fN;
            elist->fTreeNumber = fTreeNumber;
            elist->fBlocks = fBlocks;
            fBlocks = 0;
            elist->fNBlocks = fNBlocks;
            fLists->Add(elist);
            elist = new TEntryList("", "", treename, fn.Data());
            if (elist->GetDirectory()) {
               //sub lists are not added to the current directory
               elist->GetDirectory()->Remove(elist);
               elist->SetDirectory(0);
            }
            fLists->Add(elist);
            fCurrent = elist;
            //the current entry list was changed. reset the fLastIndexQueried,
            //so that Next() doesn't start with the wrong current list
            fLastIndexQueried = -3;

         }
         else {
            //same tree as in the current entry list, don't do anything
            return;
         }
      }
   }
}

//______________________________________________________________________________
void TEntryList::SetTree(const TTree *tree)
{
   //If a list for a tree with such name and filename exists, sets it as the current sublist
   //If not, creates this list and sets it as the current sublist
   //The name of the file, where the tree is, is taken as
   //tree->GetTree()->GetCurrentFile()->GetName(), and then expanded either to the absolute path,
   //or to full url. If, for some reason, you want to provide
   //the filename in a different format, use SetTree(const char *treename, const char *filename),
   //where the filename is taken "as is".

   if (!tree) return;
   auto thisTree = tree->GetTree();
   if (!thisTree) return;

   TString treename;
   if (TFile::Class() == tree->GetDirectory()->IsA())
      treename = thisTree->GetName();
   else {
      treename = TString::Format("%s/%s",tree->GetDirectory()->GetName(),thisTree->GetName());
   }

   TString filename;
   if (tree->GetTree()->GetCurrentFile()){
      filename = tree->GetTree()->GetCurrentFile()->GetName();
      TUrl url(filename.Data(), kTRUE);
      if (!strcmp(url.GetProtocol(), "file")){
         gSystem->ExpandPathName(filename);
         if (!gSystem->IsAbsoluteFileName(filename))
            gSystem->PrependPathName(gSystem->pwd(), filename);
         filename = gSystem->UnixPathName(filename);
         url.SetFile(filename);
      }
      filename = url.GetUrl();
   } else {
      //memory-resident
      filename = "";
   }
   SetTree(treename, filename);

}

//______________________________________________________________________________
void TEntryList::Subtract(const TEntryList *elist)
{
   //remove all the entries of this entry list, that are contained in elist

   TEntryList *templist = 0;
   if (!fLists){
      if (!fBlocks) return;
      //check if lists are for the same tree
      if (!elist->fLists){
         //second list is also only for 1 tree
         if (!strcmp(elist->fTreeName.Data(),fTreeName.Data()) &&
             !strcmp(elist->fFileName.Data(),fFileName.Data())){
            //same tree
            Long64_t n2 = elist->GetN();
            Long64_t entry;
            for (Int_t i=0; i<n2; i++){
               entry = (const_cast<TEntryList*>(elist))->GetEntry(i);
               Remove(entry);
            }
         } else {
            //different trees
            return;
         }
      } else {
         //second list has sublists, try to find one for the same tree as this list
         TIter next1(elist->GetLists());
         templist = 0;
         Bool_t found = kFALSE;
         while ((templist = (TEntryList*)next1())){
            if (!strcmp(templist->fTreeName.Data(),fTreeName.Data()) &&
                !strcmp(templist->fFileName.Data(),fFileName.Data())){
               found = kTRUE;
               break;
            }
         }
         if (found) {
            Subtract(templist);
         }
      }
   } else {
      //this list has sublists
      TIter next2(fLists);
      templist = 0;
      Long64_t oldn=0;
      while ((templist = (TEntryList*)next2())){
         oldn = templist->GetN();
         templist->Subtract(elist);
         fN = fN - oldn + templist->GetN();
      }
   }
   return;


}

//______________________________________________________________________________
TEntryList operator||(TEntryList &elist1, TEntryList &elist2)
{
   TEntryList eresult = elist1;
   //eresult = elist1;
   // printf("internal in operator1\n");
   eresult.Print("all");
   eresult.Add(&elist2);
   // printf("internal in operator2\n");
   eresult.Print("all");

   return eresult;
}

//________________________________________________________________________
Int_t TEntryList::RelocatePaths(const char *newroot, const char *oldroot)
{
   // Relocate the file paths.
   // If 'oldroot' is defined, replace 'oldroot' with 'newroot' in all file names,
   // i.e. <oldroot>/re/st/of/the/path will become <newroot>/re/st/of/the/path .
   // If 'oldroot' is null, the new path will be just <newroot>/path .
   // Relocation is mandatory to use the entry-list with the same dataset at a different
   // location (i.e. on a different cluster, machine or disks).

   // At least newroot must be given
   if (!newroot || (newroot && strlen(newroot) <= 0)) {
      Warning("RelocatePaths", "the new location must be given!");
      return -1;
   }

   if (strlen(GetName()) > 0)
      Info("RelocatePaths", "'%s': relocating paths '%s' to '%s'",
                            GetName(), oldroot ? oldroot : "*", newroot);

   Int_t nrl = 0, xnrl = 0;
   // Apply to all underlying lists, if any
   if (fLists) {
      TIter nxl(fLists);
      TEntryList *enl = 0;
      while ((enl = (TEntryList *) nxl())) {
         if ((xnrl = enl->RelocatePaths(newroot, oldroot)) < 0) {
            Warning("RelocatePaths", "problems relocating '%s'", enl->GetName());
         } else {
            nrl += xnrl;
         }
      }
   }
   // Apply to ourselves
   TString temp;
   Ssiz_t lo = 0;
   if (oldroot && (lo = strlen(oldroot)) > 0) {
      if (fFileName.BeginsWith(oldroot)) {
         fFileName.Replace(0, lo, newroot);
         nrl++;
      }
   } else {
      Ssiz_t ilst = fFileName.Last('/');
      if (ilst != kNPOS) {
         fFileName.Replace(0, ilst, newroot);
      } else {
         fFileName.Insert(0, TString::Format("%s/", newroot));
      }
      nrl++;
   }
   if (fStringHash != 0) {
      temp.Form("%s%s", fTreeName.Data(), fFileName.Data());
      fStringHash = temp.Hash();
   }

   // Done
   return nrl;
}

//________________________________________________________________________
Int_t TEntryList::Relocate(const char *fn,
                          const char *newroot, const char *oldroot, const char *enlnm)
{
   // Relocate entry list 'enlnm' in file 'fn' replacing 'oldroot' with 'newroot' in
   // filenames. If 'enlnm' is null or '*' all entry lists in the file are relocated.
   // Relocation is mandatory to use the entry-list with the same dataset at a different
   // location (i.e. on a different cluster, machine or disks).
   // This function can be called as many times as need to reach the desired result.
   // The existing 'locations' can be checked qith TEntryList::Scan .

   // Open the file for updating
   TFile *fl = TFile::Open(fn, "UPDATE");
   if (!fl || (fl&& fl->IsZombie())) {
      ::Error("TEntryList::Relocate", "file '%s' cannot be open for updating", fn);
      return -1;
   }

   Int_t nrl = 0;
   // Read the lists
   TString nm(enlnm);
   if (nm.IsNull()) nm = "*";
   TRegexp nmrg(nm, kTRUE);
   TIter nxk(fl->GetListOfKeys());
   TKey *key = 0;
   while ((key = (TKey *) nxk())) {
      if (!strcmp(key->GetClassName(), "TEntryList")) {
         TString knm(key->GetName());
         if (knm.Index(nmrg) != kNPOS) {
            TEntryList *enl = dynamic_cast<TEntryList *>(fl->Get(knm));
            if (enl) {
               Int_t xnrl = enl->RelocatePaths(newroot, oldroot);
               if (xnrl >= 0) {
                  enl->Write(knm, TObject::kOverwrite);
                  nrl += xnrl;
               } else {
                  ::Error("TEntryList::Relocate", "problems relocating '%s' ...", enl->GetName());
               }
            }
         }
      }
   }
   // Close the file
   fl->Close();
   delete fl;
   // Done
   return nrl;
}

//______________________________________________________________________________
static Int_t GetCommonString(TString a, TString b, TString &c)
{
   // Get in 'c' the string in common at the beginning of 'a' and 'b'
   // Return
   //          0         a and b are not contained in each other, i.e. c != a && c != b
   //          1         a is contained in b, i.e. c == a (includes a == empty)
   //          2         b is contained in a, i.e. c == b (includes b == empty)
   //          3         b is a, i.e. c == b == a (includes a == b == empty)
   // Auxilliary function for path scans.

   if (a == b) {
      c = a;
      return 3;
   }
   if (a.IsNull()) {
      c = "";
      return 1;
   }
   if (b.IsNull()) {
      c = "";
      return 2;
   }
   Bool_t ashort = (a.Length() > b.Length()) ? kFALSE : kTRUE;
   Ssiz_t len = (ashort) ? a.Length() : b.Length();
   Int_t lcom = 0;
   for (Int_t i = 0; i < len; i++) {
      if (a[i] != b[i]) break;
      lcom++;
   }
   if (lcom == len) {
      c = ashort ? a : b;
      return ashort ? 1 : 2;
   }
   c = a(0,lcom);
   // Done
   return 0;
}

//________________________________________________________________________
Int_t TEntryList::ScanPaths(TList *roots, Bool_t notify)
{
   // Scan the paths to find the common roots. If 'roots' is defined, add
   // the found roots to the list as TObjStrings.
   // Return the number of roots found.

   TList *xrl = roots ? roots : new TList;

   Int_t nrl = 0;
   // Apply to all underlying lists, if any
   if (fLists) {
      TIter nxl(fLists);
      TEntryList *enl = 0;
      while ((enl = (TEntryList *) nxl()))
         nrl += enl->ScanPaths(xrl, kFALSE);
   }
   // Apply to ourselves
   Bool_t newobjs = kTRUE;
   TString path = gSystem->DirName(fFileName), com;
   TObjString *objs = 0;
   TIter nxr(xrl);
   while ((objs = (TObjString *) nxr())) {
      Int_t rc = 0;
      if ((rc = GetCommonString(path, objs->GetString(), com)) != 2) {
         TUrl ucom(com);
         if (strlen(ucom.GetFile()) > 0 && strcmp(ucom.GetFile(), "/")) {
            objs->SetString(com.Data());
            newobjs = kFALSE;
            break;
         }
      }
   }
   if (newobjs) xrl->Add(new TObjString(path));

   // Done
   nrl = xrl->GetSize();
   if (notify) {
      Printf(" * ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ *");
      Printf(" * Entry-list: %s", GetName());
      Printf(" *   %d commont root paths found", nrl);
      nxr.Reset();
      while ((objs = (TObjString *) nxr())) {
         Printf(" *     %s", objs->GetName());
      }
      Printf(" * ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ *");
   }

   if (xrl != roots) {
      xrl->SetOwner(kTRUE);
      SafeDelete(xrl);
   }

   // Done
   return nrl;
}

//________________________________________________________________________
Int_t TEntryList::Scan(const char *fn, TList *roots)
{
   // Scan TEntryList in 'fn' to find the common parts of paths.
   // If 'roots' is defined, add the found roots to the list as TObjStrings.
   // Return the number of common root paths found.

   // Open the file for updating
   TFile *fl = TFile::Open(fn);
   if (!fl || (fl&& fl->IsZombie())) {
      ::Error("TEntryList::Relocate", "file '%s' cannot be open for reading", fn);
      return -1;
   }

   Int_t nrs = 0;
   // Read the lists
   TIter nxk(fl->GetListOfKeys());
   TKey *key = 0;
   while ((key = (TKey *) nxk())) {
      if (!strcmp(key->GetClassName(), "TEntryList")) {
         TEntryList *enl = dynamic_cast<TEntryList *>(fl->Get(key->GetName()));
         if (enl) {
            nrs += enl->ScanPaths(roots);
         } else {
            ::Error("TEntryList::Scan", "object entry-list '%s' not found or not loadable!", key->GetName());
         }
      }
   }
   // Close the file
   fl->Close();
   delete fl;

   // Done
   return nrs;
}

//______________________________________________________________________________
void TEntryList::Streamer(TBuffer &b)
{
   // Custom streamer for class TEntryList to handle the different interpretation
   // of fFileName between version 1 and >1 .

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