// @(#)root/proofplayer:$Id$
// Author: Maarten Ballintijn   07/01/02
// Modified: Long Tran-Thanh    04/09/07  (Addition of TEventIterUnit)

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

//////////////////////////////////////////////////////////////////////////
//                                                                      //
// TEventIter                                                           //
//                                                                      //
// Special iterator class used in TProofPlayer to iterate over events   //
// or objects in the packets.                                           //
//                                                                      //
//////////////////////////////////////////////////////////////////////////

#include "TEnv.h"
#include "TEventIter.h"
#include "TFriendElement.h"
#include "TCollection.h"
#include "TDSet.h"
#include "TFile.h"
#include "TKey.h"
#include "TProofDebug.h"
#include "TSelector.h"
#include "TTimeStamp.h"
#include "TTree.h"
#include "TTreeCache.h"
#include "TTreeCacheUnzip.h"
#include "TVirtualPerfStats.h"
#include "TEventList.h"
#include "TEntryList.h"
#include "TList.h"
#include "TMap.h"
#include "TObjString.h"
#include "TRegexp.h"
#include "TProofServ.h"
#include "TSystem.h"

#include "TError.h"

#if defined(R__MACOSX)
#include "fcntl.h"
#endif

ClassImp(TEventIter)

//______________________________________________________________________________
TEventIter::TEventIter()
{
   // Default constructor

   fDSet  = 0;
   fElem  = 0;
   fFile  = 0;
   fDir   = 0;
   fSel   = 0;
   fFirst = 0;
   fCur   = -1;
   fNum   = 0;
   fStop  = kFALSE;
   fOldBytesRead = 0;
   fEventList = 0;
   fEventListPos = 0;
   fEntryList = 0;
   fEntryListPos = 0;
   fElemFirst = 0;
   fElemNum = 0;
   fElemCur = -1;
   ResetBit(TEventIter::kData);

   if ((fPackets = new TList)) {
      TString n("ProcessedPackets_");
      if (gProofServ) n += gProofServ->GetOrdinal();
      fPackets->SetName(n);
      Info("TEventIter", "fPackets list '%s' created", n.Data());
   } else {
      Warning("TEventIter", "fPackets list could not be created");
   }
}

//______________________________________________________________________________
TEventIter::TEventIter(TDSet *dset, TSelector *sel, Long64_t first, Long64_t num)
   : fDSet(dset), fSel(sel)
{
   // Constructor

   fElem  = 0;
   fFile  = 0;
   fDir   = 0;
   fFirst = first;
   fCur   = -1;
   fNum   = num;
   fStop  = kFALSE;
   fEventList = 0;
   fEventListPos = 0;
   fEntryList = 0;
   fEntryListPos = 0;
   fOldBytesRead = 0;
   fElemFirst = 0;
   fElemNum = 0;
   fElemCur = -1;
   ResetBit(TEventIter::kData);

   if ((fPackets = new TList)) {
      TString n("ProcessedPackets_");
      if (gProofServ) n += gProofServ->GetOrdinal();
      fPackets->SetName(n);
      Info("TEventIter", "fPackets list '%s' created", n.Data());
   } else {
      Warning("TEventIter", "fPackets list could not be created");
   }
}

//______________________________________________________________________________
TEventIter::~TEventIter()
{
   // Destructor

   if (fPackets) {
      fPackets->SetOwner(kTRUE);
      SafeDelete(fPackets);
   }
   delete fFile;
}

//______________________________________________________________________________
void TEventIter::InvalidatePacket()
{
   // Invalidated the current packet (if any) by setting the TDSetElement::kCorrupted bit

   if (fElem) fElem->SetBit(TDSetElement::kCorrupted);
}

//______________________________________________________________________________
void TEventIter::StopProcess(Bool_t /*abort*/)
{
   // Set flag to stop the process

   fStop = kTRUE;
}

//______________________________________________________________________________
TEventIter *TEventIter::Create(TDSet *dset, TSelector *sel, Long64_t first, Long64_t num)
{
   // Create and instance of the appropriate iterator

   if (dset->TestBit(TDSet::kEmpty)) {
      return new TEventIterUnit(dset, sel, num);
   }  else if (dset->IsTree()) {
      return new TEventIterTree(dset, sel, first, num);
   } else {
      return new TEventIterObj(dset, sel, first, num);
   }
}

//______________________________________________________________________________
Int_t TEventIter::LoadDir()
{
   // Load directory

   Int_t ret = 0;

   // Check Filename
   if ( fFile == 0 || fFilename != fElem->GetFileName() ) {
      fDir = 0;
      delete fFile; fFile = 0;

      fFilename = fElem->GetFileName();

      TDirectory *dirsave = gDirectory;

      Double_t start = 0;
      if (gPerfStats) start = TTimeStamp();

      // Take into acoount possible prefixes
      TFile::EFileType typ = TFile::kDefault;
      TString fname = gEnv->GetValue("Path.Localroot","");
      if (!fname.IsNull())
         typ = TFile::GetType(fFilename, "", &fname);
      if (typ != TFile::kLocal)
         fname = fFilename;
      fFile = TFile::Open(fname);

      if (gPerfStats) {
         gPerfStats->FileOpenEvent(fFile, fFilename, start);
         fOldBytesRead = 0;
      }

      if (dirsave) dirsave->cd();

      if (!fFile || fFile->IsZombie() ) {
         if (fFile)
            Error("Process","Cannot open file: %s (%s)",
               fFilename.Data(), strerror(fFile->GetErrno()) );
         else
            Error("Process","Cannot open file: %s (errno unavailable)",
               fFilename.Data());
         // cleanup ?
         return -1;
      }
      PDB(kLoop,2) Info("LoadDir","Opening file: %s", fFilename.Data() );
      ret = 1;
   }

   // Check Directory
   if ( fDir == 0 || fPath != fElem->GetDirectory() ) {
      TDirectory *dirsave = gDirectory;

      fPath = fElem->GetDirectory();
      if ( !fFile->cd(fPath) ) {
         Error("Process","Cannot cd to: %s",
            fPath.Data() );
         return -1;
      }
      PDB(kLoop,2) Info("Process","Cd to: %s", fPath.Data() );
      fDir = gDirectory;
      if (dirsave) dirsave->cd();
      ret = 1;
   }

   return ret;
}

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


ClassImp(TEventIterUnit)

//______________________________________________________________________________
TEventIterUnit::TEventIterUnit()
{
   // Default constructor

   fDSet = 0;
   fElem = 0;
   fSel = 0;
   fNum = 0;
   fCurrent = 0;
   fStop = kFALSE;
   fOldBytesRead = 0; // Measures the bytes written
}

//______________________________________________________________________________
TEventIterUnit::TEventIterUnit(TDSet* dset, TSelector *sel, Long64_t num)
{
   // Main constructor

   fDSet = dset;
   fElem = 0;
   fSel = sel;
   fNum = num;
   fCurrent = 0;
   fStop = kFALSE;
   fOldBytesRead = 0; // Measures the bytes written
}

//______________________________________________________________________________
Int_t TEventIterUnit::GetNextPacket(Long64_t &fst, Long64_t &num,
                                   TEntryList **, TEventList **)
{
   // Get loop range

   if (gPerfStats) {
      Long64_t totBytesWritten = TFile::GetFileBytesWritten();
      Long64_t bytesWritten = totBytesWritten - fOldBytesRead;
      PDB(kLoop, 2) Info("GetNextPacket", "bytes written: %lld", bytesWritten);
      gPerfStats->SetBytesRead(bytesWritten);
      fOldBytesRead = totBytesWritten;
   }

   if (fDSet->TestBit(TDSet::kIsLocal)) {
      if (fElem) {
         if (fPackets) {
            fPackets->Add(fElem);
            PDB(kLoop, 2)
               Info("GetNextEvent", "packet added to list (sz: %d)", fPackets->GetSize());
            fElem = 0;
         } else {
            SafeDelete(fElem);
         }
         return -1;
      } else {
         fElem = new TDSetElement("", "", "", 0, fNum);
         fElem->SetBit(TDSetElement::kEmpty);
      }
   } else {
      if (fPackets && fElem) {
         fPackets->Add(fElem);
         PDB(kLoop, 2)
            Info("GetNextEvent", "packet added to list (sz: %d)", fPackets->GetSize());
         fElem = 0;
      } else {
         SafeDelete(fElem);
      }
      if (!(fElem = fDSet->Next()))
         return -1;
   }
   fElem->SetBit(TDSetElement::kNewPacket);

   if (!fElem->TestBit(TDSetElement::kEmpty)) {
      Error("GetNextPacket", "data element must be set to kEmtpy");
      return -1;
   }

   // Set output
   num = fElem->GetNum();
   if (num == 0) return -1;
   fst = fElem->GetFirst();

   // Done
   return 0;
}

//______________________________________________________________________________
Long64_t TEventIterUnit::GetNextEvent()
{
   // Get next event

   if (fStop || fNum == 0)
      return -1;

   if (fElem) fElem->ResetBit(TDSetElement::kNewPacket);

   while (fElem == 0 || fCurrent == 0) {

      if (gPerfStats) {
         Long64_t totBytesWritten = TFile::GetFileBytesWritten();
         Long64_t bytesWritten = totBytesWritten - fOldBytesRead;
         PDB(kLoop, 2) Info("GetNextEvent", "bytes written: %lld", bytesWritten);
         gPerfStats->SetBytesRead(bytesWritten);
         fOldBytesRead = totBytesWritten;
      }

      if (fDSet->TestBit(TDSet::kIsLocal)) {
         if (fElem) {
            if (fPackets) {
               fPackets->Add(fElem);
               PDB(kLoop, 2)
                  Info("GetNextEvent", "packet added to list (sz: %d)", fPackets->GetSize());
               fElem = 0;
            } else {
               SafeDelete(fElem);
            }
            return -1;
         } else {
            fElem = new TDSetElement("", "", "", 0, fNum);
            fElem->SetBit(TDSetElement::kEmpty);
         }
      } else {
         if (fPackets && fElem) {
            fPackets->Add(fElem);
            PDB(kLoop, 2)
               Info("GetNextEvent", "packet added to list (sz: %d)", fPackets->GetSize());
            fElem = 0;
         } else {
            SafeDelete(fElem);
         }
         if (!(fElem = fDSet->Next()))
            return -1;
      }
      fElem->SetBit(TDSetElement::kNewPacket);

      if (!fElem->TestBit(TDSetElement::kEmpty)) {
         Error("GetNextEvent", "data element must be set to kEmtpy");
         return -1;
      }

      fNum = fElem->GetNum();
      if (!(fCurrent = fNum)) {
         fNum = 0;
         return -1;
      }
      fFirst = fElem->GetFirst();
   }
   Long64_t event = fNum - fCurrent + fFirst ;
   --fCurrent;
   return event;
}

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


ClassImp(TEventIterObj)

//______________________________________________________________________________
TEventIterObj::TEventIterObj()
{
   // Default ctor.

   fKeys     = 0;
   fNextKey  = 0;
   fObj      = 0;
}

//______________________________________________________________________________
TEventIterObj::TEventIterObj(TDSet *dset, TSelector *sel, Long64_t first, Long64_t num)
   : TEventIter(dset,sel,first,num)
{
   // Constructor

   fClassName = dset->GetType();
   fKeys     = 0;
   fNextKey  = 0;
   fObj      = 0;
}


//______________________________________________________________________________
TEventIterObj::~TEventIterObj()
{
   // Destructor

   // delete fKeys ?
   delete fNextKey;
   delete fObj;
}

//______________________________________________________________________________
Int_t TEventIterObj::GetNextPacket(Long64_t &first, Long64_t &num,
                                  TEntryList **, TEventList **)
{
   // Get loop range

   SafeDelete(fElem);

   if (fStop || fNum == 0) return -1;

   while (fElem == 0 || fCur < fFirst-1) {

      if (gPerfStats && fFile) {
         Long64_t bytesRead = fFile->GetBytesRead();
         gPerfStats->SetBytesRead(bytesRead - fOldBytesRead);
         fOldBytesRead = bytesRead;
      }

      if (fElem) {
         // Save it to the list of processed packets
         if (fPackets) {
            fPackets->Add(fElem);
            fElem = 0;
         } else {
            SafeDelete(fElem);
         }
      }
      fElem = fDSet->Next(fKeys->GetSize());
      if (fElem && fElem->GetEntryList()) {
         Error("GetNextPacket", "entry- or event-list not available");
         return -1;
      }

      if ( fElem == 0 ) {
         fNum = 0;
         return -1;
      }
      fElem->SetBit(TDSetElement::kNewPacket);

      Int_t r = LoadDir();

      if ( r == -1 ) {

         // Error has been reported
         fNum = 0;
         return -1;

      } else if ( r == 1 ) {

         // New file and/or directory
         fKeys = fDir->GetListOfKeys();
         fNextKey = new TIter(fKeys);
      }

      // Validate values for this element
      fElemFirst = fElem->GetFirst();
      fElemNum = fElem->GetNum();
      if (fElem->GetEntryList()) {
         if (!(fEntryList = dynamic_cast<TEntryList *>(fElem->GetEntryList())))
            fEventList = dynamic_cast<TEventList *>(fElem->GetEntryList());
      }
      fEventListPos = 0;
      if (fEntryList)
         fElemNum = fEntryList->GetEntriesToProcess();
      else if (fEventList)
         fElemNum = fEventList->GetN();

      Long64_t tnum = fKeys->GetSize();

      if ( fElemFirst > tnum ) {
         Error("GetNextPacket","First (%lld) higher then number of keys (%lld) in %s",
               fElemFirst, tnum, fElem->GetName());
         fNum = 0;
         return -1;
      }

      if ( fElemNum == -1 ) {
         fElemNum = tnum - fElemFirst;
      } else if ( fElemFirst+fElemNum  > tnum ) {
         Error("GetNextPacket","Num (%lld) + First (%lld) larger then number of keys (%lld) in %s",
            fElemNum, fElemFirst, tnum, fElem->GetDirectory());
         fElemNum = tnum - fElemFirst;
      }

      // Skip this element completely?
      if ( fCur + fElemNum < fFirst ) {
         fCur += fElemNum;
         continue;
      }

      // Position within this element
      fNextKey->Reset();
      for(fElemCur = -1; fElemCur < fElemFirst-1 ; fElemCur++, fNextKey->Next()) { }
   }

   first = ++fElemCur;
   num = fElemNum;

   // Done
   return 0;
}
//______________________________________________________________________________
void TEventIterObj::PreProcessEvent(Long64_t)
{
   // To be executed before by TProofPlayer calling TSelector::Process

   --fNum;
   ++fCur;
   TKey *key = (TKey*) fNextKey->Next();
   TDirectory *dirsave = gDirectory;
   fDir->cd();
   fObj = key->ReadObj();
   if (dirsave) dirsave->cd();
   fSel->SetObject(fObj);
}

//______________________________________________________________________________
Long64_t TEventIterObj::GetNextEvent()
{
   // Get next event

   if (fStop || fNum == 0) return -1;

   if (fElem) fElem->ResetBit(TDSetElement::kNewPacket);

   while ( fElem == 0 || fElemNum == 0 || fCur < fFirst-1 ) {

      if (gPerfStats && fFile) {
         Long64_t bytesRead = fFile->GetBytesRead();
         gPerfStats->SetBytesRead(bytesRead - fOldBytesRead);
         fOldBytesRead = bytesRead;
      }

      if (fElem) {
         // Save it to the list of processed packets
         if (fPackets) {
            fPackets->Add(fElem);
            fElem = 0;
         } else {
            SafeDelete(fElem);
         }
      }
      fElem = fDSet->Next(fKeys->GetSize());
      if (fElem && fElem->GetEntryList()) {
         Error("GetNextEvent", "Entry- or event-list not available");
         return -1;
      }

      if ( fElem == 0 ) {
         fNum = 0;
         return -1;
      }
      fElem->SetBit(TDSetElement::kNewPacket);

      Int_t r = LoadDir();

      if ( r == -1 ) {

         // Error has been reported
         fNum = 0;
         return -1;

      } else if ( r == 1 ) {

         // New file and/or directory
         fKeys = fDir->GetListOfKeys();
         fNextKey = new TIter(fKeys);
      }

      // Validate values for this element
      fElemFirst = fElem->GetFirst();
      fElemNum = fElem->GetNum();
      if (fElem->GetEntryList()) {
         if (!(fEntryList = dynamic_cast<TEntryList *>(fElem->GetEntryList())))
            fEventList = dynamic_cast<TEventList *>(fElem->GetEntryList());
      }
      fEventListPos = 0;
      if (fEntryList)
         fElemNum = fEntryList->GetEntriesToProcess();
      else if (fEventList)
         fElemNum = fEventList->GetN();

      Long64_t num = fKeys->GetSize();

      if ( fElemFirst > num ) {
         Error("GetNextEvent","First (%lld) higher then number of keys (%lld) in %s",
               fElemFirst, num, fElem->GetName());
         fNum = 0;
         return -1;
      }

      if ( fElemNum == -1 ) {
         fElemNum = num - fElemFirst;
      } else if ( fElemFirst+fElemNum  > num ) {
         Error("GetNextEvent","Num (%lld) + First (%lld) larger then number of keys (%lld) in %s",
            fElemNum, fElemFirst, num, fElem->GetDirectory());
         fElemNum = num - fElemFirst;
      }

      // Skip this element completely?
      if ( fCur + fElemNum < fFirst ) {
         fCur += fElemNum;
         continue;
      }

      // Position within this element. TODO: more efficient?
      fNextKey->Reset();
      for(fElemCur = -1; fElemCur < fElemFirst-1 ; fElemCur++, fNextKey->Next()) { }
   }

   --fElemNum;
   ++fElemCur;

   // Pre-event processing
   PreProcessEvent(fElemCur);

   return fElemCur;
}

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

//______________________________________________________________________________
TEventIterTree::TFileTree::TFileTree(const char *name, TFile *f, Bool_t islocal)
               : TNamed(name, ""), fUsed(kFALSE), fIsLocal(islocal), fFile(f)
{
   // Default ctor.

   fTrees = new TList;
   fTrees->SetOwner();
}
//______________________________________________________________________________
TEventIterTree::TFileTree::~TFileTree()
{
   // Default dtor.

   // Avoid destroying the cache; must be placed before deleting the trees
   TTree *tree = (TTree *)fTrees->First();
   while (tree) {
      fFile->SetCacheRead(0, tree);
      tree = (TTree *)fTrees->After(tree);
   }
   SafeDelete(fTrees);
   SafeDelete(fFile);
}

ClassImp(TEventIterTree)

//______________________________________________________________________________
TEventIterTree::TEventIterTree()
{
   // Default ctor.

   fTree = 0;
   fTreeCache = 0;
   fUseTreeCache = 1;
   fCacheSize = -1;
   fTreeCacheIsLearning = kTRUE;
   fFileTrees = 0;
   fUseParallelUnzip = 0;
   fDontCacheFiles = kFALSE;
   SetBit(TEventIter::kData);
}

//______________________________________________________________________________
TEventIterTree::TEventIterTree(TDSet *dset, TSelector *sel, Long64_t first, Long64_t num)
   : TEventIter(dset,sel,first,num)
{
   // Constructor

   fTreeName = dset->GetObjName();
   fTree = 0;
   fTreeCache = 0;
   fTreeCacheIsLearning = kTRUE;
   fFileTrees = new TList;
   fFileTrees->SetOwner();
   fUseTreeCache = gEnv->GetValue("ProofPlayer.UseTreeCache", 1);
   fCacheSize = gEnv->GetValue("ProofPlayer.CacheSize", -1);
   fUseParallelUnzip = gEnv->GetValue("ProofPlayer.UseParallelUnzip", 0);
   if (fUseParallelUnzip) {
      TTreeCacheUnzip::SetParallelUnzip(TTreeCacheUnzip::kEnable);
   } else {
      TTreeCacheUnzip::SetParallelUnzip(TTreeCacheUnzip::kDisable);
   }
   fDontCacheFiles = gEnv->GetValue("ProofPlayer.DontCacheFiles", 0);
   SetBit(TEventIter::kData);
}

//______________________________________________________________________________
TEventIterTree::~TEventIterTree()
{
   // Destructor

   // Delete the tree cache ...
   SafeDelete(fTreeCache);
   // ... and the remaining open files
   SafeDelete(fFileTrees);
}

//______________________________________________________________________________
Long64_t TEventIterTree::GetCacheSize()
{
   // Return the size in bytes of the cache, if any
   // Return -1 if not used

   if (fUseTreeCache) return fCacheSize;
   return -1;
}

//______________________________________________________________________________
Int_t TEventIterTree::GetLearnEntries()
{
   // Return the number of entries in the learning phase

   return TTreeCache::GetLearnEntries();
}

//______________________________________________________________________________
TTree* TEventIterTree::GetTrees(TDSetElement *elem)
{
   // Create a Tree for the main TDSetElement and for all the friends.
   // Returns the main tree or 0 in case of an error.

   // Reset used flags
   TIter nxft(fFileTrees);
   TFileTree *ft = 0;
   while ((ft = (TFileTree *)nxft()))
      ft->fUsed = kFALSE;

   Bool_t localfile = kFALSE;
   TTree* main = Load(elem, localfile);

   if (main && main != fTree) {
      // Set the file cache
      if (fUseTreeCache) {
         TFile *curfile = main->GetCurrentFile();
         if (curfile) {
            if (!fTreeCache) {
               main->SetCacheSize(fCacheSize);
               fTreeCache = (TTreeCache *)curfile->GetCacheRead(main);
               if (fCacheSize < 0) fCacheSize = main->GetCacheSize();
            } else {
               curfile->SetCacheRead(fTreeCache, main);
               fTreeCache->UpdateBranches(main);
            }
            if (fTreeCache) {
               fTreeCacheIsLearning = fTreeCache->IsLearning();
               if (fTreeCacheIsLearning)
                  Info("GetTrees","the tree cache is in learning phase");
            }
         } else {
            Warning("GetTrees", "default tree does nto have a file attached: corruption? Tree cache untouched");
         }
      } else {
         // Disable the cache
         main->SetCacheSize(0);
      }
   }
   Bool_t loc = kFALSE;
   // Also the friends
   TList *friends = elem->GetListOfFriends();
   if (friends) {
      TIter nxf(friends);
      TDSetElement *dse = 0;
      while ((dse = (TDSetElement *) nxf())) {
         // The alias, if any, is in the element name options ('friend_alias=<alias>|')
         TUrl uf(dse->GetName());
         TString uo(uf.GetOptions()), alias;
         Int_t from = kNPOS;
         if ((from = uo.Index("friend_alias=")) != kNPOS) {
            from += strlen("friend_alias=");
            if (!uo.Tokenize(alias, from, "|"))
               Warning("GetTrees", "empty 'friend_alias' found for tree friend");
            // The options may be used for other things, so remove the internal strings once decoded
            uo.ReplaceAll(TString::Format("friend_alias=%s|", alias.Data()), "");
            uf.SetOptions(uo);
            dse->SetName(uf.GetUrl());
         }
         TTree *friendTree = Load(dse, loc, dse->GetObjName());
         if (friendTree && main) {
            // Make sure it has not yet been added
            Bool_t addfriend = kTRUE;
            TList *frnds = main->GetListOfFriends();
            if (frnds) {
               TIter xnxf(frnds);
               TFriendElement *fe = 0;
               while ((fe = (TFriendElement *) xnxf())) {
                  if (fe->GetTree() == friendTree) {
                     addfriend = kFALSE;
                     break;
                  }
               }
            }
            if (addfriend) {
               if (alias.IsNull())
                  main->AddFriend(friendTree);
               else
                  main->AddFriend(friendTree, alias);
            }
         } else {
            return 0;
         }
      }
   }

   // Remove instances not used
   nxft.Reset();
   while ((ft = (TFileTree *)nxft())) {
      if (!(ft->fUsed)) {
         fFileTrees->Remove(ft);
         delete ft;
      }
   }

   // Done, successfully or not
   return main;
}

//______________________________________________________________________________
TTree* TEventIterTree::Load(TDSetElement *e, Bool_t &localfile, const char *objname)
{
   // Load a tree from s TDSetElement

   if (!e) {
      Error("Load", "undefined element");
      return (TTree *)0;
   }

   const char *fn = e->GetFileName();
   const char *dn = e->GetDirectory();
   const char *tn = 0;
   if (objname && strlen(objname) > 0) {
      tn = objname;
   } else {
      tn = (fDSet->GetObjName() && strlen(fDSet->GetObjName()) > 0)
         ? fDSet->GetObjName() : e->GetObjName();
      if (!tn || (tn && strlen(tn) <= 0)) tn = "*";
   }
   PDB(kLoop,2)
      Info("Load","loading: fn:'%s' dn:'%s' tn:'%s'", fn, dn, tn);

   TFile *f = 0;

   // Check if the file is already open
   TString names(fn);
   TString name;
   Ssiz_t from = 0;
   TFileTree *ft = 0;
   while (names.Tokenize(name,from,"|")) {
      TString key(TUrl(name).GetFileAndOptions());
      if ((ft = (TFileTree *) fFileTrees->FindObject(key.Data()))) {
         f = ft->fFile;
         break;
      }
   }

   // Open the file, if needed
   if (!f) {
      TFile::EFileType typ = TFile::kDefault;
      TString fname = gEnv->GetValue("Path.Localroot","");
      if (!fname.IsNull())
         typ = TFile::GetType(fn, "", &fname);
      if (typ != TFile::kLocal) {
         fname = fn;
      } else {
         localfile = kTRUE;
      }

      // Open the file
      f = TFile::Open(fname);
      if (!f) {
         Error("Load","file '%s' ('%s') could not be open", fn, fname.Data());
         return (TTree *)0;
      }

#if defined(R__MACOSX)
      // If requested set the no cache mode
      if (fDontCacheFiles && localfile) {
         fcntl(f->GetFd(), F_NOCACHE, 1);
      }
#endif

      // Create TFileTree instance in the list
      ft = new TFileTree(TUrl(f->GetName()).GetFileAndOptions(), f, localfile);
      fFileTrees->Add(ft);
   } else {
      // Fill locality boolean
      localfile = ft->fIsLocal;
      PDB(kLoop,2)
         Info("Load","file '%s' already open (local:%d)", fn, localfile);
   }

   // Check if the tree is already loaded
   if (ft && ft->fTrees->GetSize() > 0) {
      TTree *t = 0;
      if (!strcmp(tn, "*"))
         t = (TTree *) ft->fTrees->First();
      else
         t = (TTree *) ft->fTrees->FindObject(tn);
      if (t) {
         ft->fUsed = kTRUE;
         return t;
      }
   }

   TDirectory *dd = f;
   // Change dir, if required
   if (dn && !(dd = f->GetDirectory(dn))) {
      Error("Load","Cannot get to: %s", dn);
      return (TTree *)0;
   }
   PDB(kLoop,2)
      Info("Load","got directory: %s", dn);

   // If a wild card we will use the first object of the type
   // requested compatible with the reg expression we got
   TString on(tn);
   TString sreg(tn);
   if (sreg.Length() <= 0 || sreg == "" || sreg.Contains("*")) {
      if (sreg.Contains("*"))
         sreg.ReplaceAll("*", ".*");
      else
         sreg = ".*";
      TRegexp re(sreg);
      if (dd->GetListOfKeys()) {
         TIter nxk(dd->GetListOfKeys());
         TKey *k = 0;
         while ((k = (TKey *) nxk())) {
            if (!strcmp(k->GetClassName(), "TTree")) {
               TString kn(k->GetName());
               if (kn.Index(re) != kNPOS) {
                  on = kn;
                  break;
               }
            }
         }
      }
   }

   // Point to the key
   TKey *key = dd->GetKey(gSystem->BaseName(on));
   if (key == 0) {
      Error("Load", "Cannot find tree \"%s\" in %s", tn, fn);
      return (TTree*)0;
   }

   PDB(kLoop,2) Info("Load", "Reading: %s", tn);

   TTree *tree = dynamic_cast<TTree*> (key->ReadObj());
   dd->cd();

   if (tree == 0) {
      Error("Load", "Cannot <dynamic_cast> obj to tree \"%s\"", tn);
      return (TTree*)0;
   }

   // Add track in the cache
   ft->fTrees->Add(tree);
   ft->fUsed = kTRUE;
   PDB(kLoop,2)
      Info("Load","TFileTree for '%s' flagged as 'in-use' ...", ft->GetName());

   // Done
   return tree;
}

//______________________________________________________________________________
Int_t TEventIterTree::GetNextPacket(Long64_t &first, Long64_t &num,
                                   TEntryList **enl, TEventList **evl)
{
   // Get loop range

   if (first > -1) fEntryListPos = first;

   if (fStop || fNum == 0) return -1;

   Bool_t attach = kFALSE;

   // When files are aborted during processing (via TSelector::kAbortFile) the player
   // invalidates the element by settign this bit. We need to ask for a new packet
   Bool_t corrupted = kFALSE;
   Long64_t rest = -1;
   if (fElem) {
      corrupted = (fElem->TestBit(TDSetElement::kCorrupted)) ? kTRUE : kFALSE;
      rest = fElem->GetNum();
      if (fElemCur >= 0) rest -= (fElemCur + 1 - fElemFirst);
   }

   SafeDelete(fElem);

   while (fElem == 0 || fElemNum == 0 || fCur < fFirst-1) {

      if (gPerfStats && fTree) {
         Long64_t totBytesRead = fTree->GetCurrentFile()->GetBytesRead();
         Long64_t bytesRead = totBytesRead - fOldBytesRead;
         gPerfStats->SetBytesRead(bytesRead);
         fOldBytesRead = totBytesRead;
      }

      if (fElem) {
         // Save it to the list of processed packets
         if (fPackets) {
            fPackets->Add(fElem);
            fElem = 0;
         } else {
            SafeDelete(fElem);
         }
      }
      while (!fElem) {
         // For a corrupted/invalid file the request for a new packet is with totalEntries = -1
         // (the default) so that the packetizer invalidates the element
         if (corrupted) {
            fElem = fDSet->Next(rest);
         } else if (fTree) {
            fElem = fDSet->Next(fTree->GetEntries());
         } else {
            fElem = fDSet->Next();
         }

         if (!fElem) {
            // End of processing
            fNum = 0;
            return -1;
         }
         corrupted = kFALSE;
         fElem->SetBit(TDSetElement::kNewPacket);
         fElem->ResetBit(TDSetElement::kCorrupted);

         TTree *newTree = GetTrees(fElem);
         if (newTree) {
            if (newTree != fTree) {
               // The old tree is owned by TFileTree and will be deleted there
               fTree = newTree;
               attach = kTRUE;
               fOldBytesRead = (fTree->GetCurrentFile()) ? fTree->GetCurrentFile()->GetBytesRead() : 0;
            }
            // Set range to be analysed
            if (fTreeCache)
               fTreeCache->SetEntryRange(fElem->GetFirst(),
                                         fElem->GetFirst() + fElem->GetNum() - 1);
         } else {
            // Could not open this element: ask for another one
            SafeDelete(fElem);
            // The current tree, if any, is not valid anymore
            fTree = 0;
         }
      }

      // Validate values for this element
      fElemFirst = fElem->GetFirst();
      fElemNum = fElem->GetNum();
      fEntryList = 0;
      fEventList = 0;
      if (fElem->GetEntryList()) {
         if (!(fEntryList = dynamic_cast<TEntryList *>(fElem->GetEntryList())))
            fEventList = dynamic_cast<TEventList *>(fElem->GetEntryList());
      }
      fEntryListPos = fElemFirst;
      fEventListPos = 0;
      if (fEntryList)
         fElemNum = fEntryList->GetEntriesToProcess();
      else if (fEventList)
         fElemNum = fEventList->GetN();

      Long64_t tnum = (Long64_t) fTree->GetEntries();

      if (!fEntryList && !fEventList) {
         if ( fElemFirst > tnum ) {
            Error("GetNextPacket", "first (%lld) higher then number of entries (%lld) in %s",
                                  fElemFirst, tnum, fElem->GetObjName());
            fNum = 0;
            return -1;
         }
         if ( fElemNum == -1 ) {
            fElemNum = tnum - fElemFirst;
         } else if ( fElemFirst+fElemNum  > tnum ) {
            Error("GetNextPacket", "num (%lld) + first (%lld) larger then number of entries (%lld) in %s",
                                  fElemNum, fElemFirst, tnum, fElem->GetName());
            fElemNum = tnum - fElemFirst;
         }

         // Skip this element completely?
         if ( fCur + fElemNum < fFirst ) {
            fCur += fElemNum;
            continue;
         }
         // Position within this element
         fElemCur = fElemFirst-1;
      }
   }

   if (attach) {
      PDB(kLoop,1) Info("GetNextPacket", "call Init(%p) and Notify()",fTree);
      fSel->Init(fTree);
      fSel->Notify();
      TIter next(fSel->GetOutputList());
      TEntryList *elist=0;
      while ((elist=(TEntryList*)next())){
         if (elist->InheritsFrom(TEntryList::Class()))
            elist->SetTree(fTree->GetName(), fElem->GetFileName());
      }
      if (fSel->GetAbort() == TSelector::kAbortProcess) {
         // the error has been reported
         return -1;
      }
      attach = kFALSE;
   }

   // Fill the output now
   num = fElemNum;
   if (fEntryList) {
      first = fEntryListPos;
      if (enl) *enl = fEntryList;
   } else if (fEventList){
      first = fEventListPos;
      if (evl) *evl = fEventList;
   } else {
      first = fElemFirst;
   }

   // Done
   return 0;
}

//______________________________________________________________________________
void TEventIterTree::PreProcessEvent(Long64_t entry)
{
   // Actions to be done just before processing entry 'entry'.
   // Called by TProofPlayer.

   if (!(fEntryList || fEventList)) {
      --fNum;
      ++fCur;
   }

   // Signal ending of learning phase
   if (fTreeCache && fTreeCacheIsLearning) {
      if (!(fTreeCache->IsLearning())) {
         fTreeCacheIsLearning = kFALSE;
         if (gProofServ) gProofServ->RestartComputeTime();
      }
   }

   // For prefetching
   if (fTree->LoadTree(entry) < 0) {
      Warning("PreEventProcess", "problems setting entry in TTree");
   }
}

//______________________________________________________________________________
Long64_t TEventIterTree::GetNextEvent()
{
   // Get next event

   if (fStop || fNum == 0) return -1;

   Bool_t attach = kFALSE;

   // When files are aborted during processing (via TSelector::kAbortFile) the player
   // invalidates the element by settign this bit. We need to ask for a new packet
   Bool_t corrupted = (fElem && fElem->TestBit(TDSetElement::kCorrupted)) ? kTRUE : kFALSE;

   if (fElem) fElem->ResetBit(TDSetElement::kNewPacket);

   while ( fElem == 0 || fElemNum == 0 || fCur < fFirst-1 || corrupted) {

      if (gPerfStats && fTree) {
         Long64_t totBytesRead = fTree->GetCurrentFile()->GetBytesRead();
         Long64_t bytesRead = totBytesRead - fOldBytesRead;
         gPerfStats->SetBytesRead(bytesRead);
         fOldBytesRead = totBytesRead;
      }

      Long64_t rest = -1;
      if (fElem) {
         rest = fElem->GetNum();
         if (fElemCur >= 0) rest -= (fElemCur + 1 - fElemFirst);
         // Save it to the list of processed packets
         if (fPackets) {
            fPackets->Add(fElem);
            fElem = 0;
         } else {
            SafeDelete(fElem);
         }
      }

      while (!fElem) {
         // For a corrupted/invalid file the request for a new packet is with totalEntries = -1
         // (the default) so that the packetizer invalidates the element
         if (corrupted) {
            fElem = fDSet->Next(rest);
         } else if (fTree) {
            fElem = fDSet->Next(fTree->GetEntries());
         } else {
            fElem = fDSet->Next();
         }

         if (!fElem) {
            // End of processing
            fNum = 0;
            return -1;
         }
         corrupted = kFALSE;
         fElem->SetBit(TDSetElement::kNewPacket);
         fElem->ResetBit(TDSetElement::kCorrupted);

         TTree *newTree = GetTrees(fElem);
         if (newTree) {
            if (newTree != fTree) {
               // The old tree is owned by TFileTree and will be deleted there
               fTree = newTree;
               attach = kTRUE;
               fOldBytesRead = (fTree->GetCurrentFile()) ? fTree->GetCurrentFile()->GetBytesRead() : 0;
            }
            // Set range to be analysed
            if (fTreeCache)
               fTreeCache->SetEntryRange(fElem->GetFirst(),
                                         fElem->GetFirst() + fElem->GetNum() - 1);
         } else {
            // Could not open this element: ask for another one
            SafeDelete(fElem);
            // The current tree, if any, is not valid anymore
            fTree = 0;
         }
      }

      // Validate values for this element
      fElemFirst = fElem->GetFirst();
      fElemNum = fElem->GetNum();
      fEntryList = dynamic_cast<TEntryList *>(fElem->GetEntryList());
      fEventList = (fEntryList) ? (TEventList *)0
                                : dynamic_cast<TEventList *>(fElem->GetEntryList());
      fEntryListPos = fElemFirst;
      fEventListPos = 0;
      if (fEntryList)
         fElemNum = fEntryList->GetEntriesToProcess();
      else if (fEventList)
         fElemNum = fEventList->GetN();

      Long64_t num = (Long64_t) fTree->GetEntries();

      if (!fEntryList && !fEventList) {
         if ( fElemFirst > num ) {
            Error("GetNextEvent", "first (%lld) higher then number of entries (%lld) in %s",
                                  fElemFirst, num, fElem->GetObjName());
            fNum = 0;
            return -1;
         }
         if ( fElemNum == -1 ) {
            fElemNum = num - fElemFirst;
         } else if ( fElemFirst+fElemNum  > num ) {
            Error("GetNextEvent", "num (%lld) + first (%lld) larger then number of entries (%lld) in %s",
                                  fElemNum, fElemFirst, num, fElem->GetName());
            fElemNum = num - fElemFirst;
         }

         // Skip this element completely?
         if ( fCur + fElemNum < fFirst ) {
            fCur += fElemNum;
            continue;
         }
         // Position within this element. TODO: more efficient?
         fElemCur = fElemFirst-1;
      }
   }

   if ( attach ) {
      PDB(kLoop,1) Info("GetNextEvent", "call Init(%p) and Notify()",fTree);
      fSel->Init(fTree);
      fSel->Notify();
      TIter next(fSel->GetOutputList());
      TEntryList *elist=0;
      while ((elist=(TEntryList*)next())){
         if (elist->InheritsFrom(TEntryList::Class()))
            elist->SetTree(fTree->GetName(), fElem->GetFileName());
      }
      if (fSel->GetAbort() == TSelector::kAbortProcess) {
         // the error has been reported
         return -1;
      }
      attach = kFALSE;
   }
   Long64_t rv;

   if (fEntryList){
      --fElemNum;
      rv = fEntryList->GetEntry(fEntryListPos);
      fEntryListPos++;
   } else if (fEventList) {
      --fElemNum;
      rv = fEventList->GetEntry(fEventListPos);
      fEventListPos++;
   } else {
      --fElemNum;
      ++fElemCur;
      rv = fElemCur;
   }

   // Pre-event processing
   PreProcessEvent(rv);

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