ROOT logo
// @(#)root/proofplayer:$Id$
// Author: Maarten Ballintijn    18/03/02

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

//////////////////////////////////////////////////////////////////////////
//                                                                      //
// TPacketizer                                                          //
//                                                                      //
// This class generates packets to be processed on PROOF worker servers.//
// A packet is an event range (begin entry and number of entries) or    //
// object range (first object and number of objects) in a TTree         //
// (entries) or a directory (objects) in a file.                        //
// Packets are generated taking into account the performance of the     //
// remote machine, the time it took to process a previous packet on     //
// the remote machine, the locality of the database files, etc.         //
//                                                                      //
//////////////////////////////////////////////////////////////////////////


#include "TPacketizer.h"

#include "Riostream.h"
#include "TDSet.h"
#include "TEnv.h"
#include "TError.h"
#include "TEventList.h"
#include "TEntryList.h"
#include "TMap.h"
#include "TMessage.h"
#include "TMonitor.h"
#include "TNtupleD.h"
#include "TObject.h"
#include "TParameter.h"
#include "TPerfStats.h"
#include "TProofDebug.h"
#include "TProof.h"
#include "TProofPlayer.h"
#include "TProofServ.h"
#include "TSlave.h"
#include "TSocket.h"
#include "TTimer.h"
#include "TUrl.h"
#include "TClass.h"
#include "TMath.h"
#include "TObjString.h"

//
// The following three utility classes manage the state of the
// work to be performed and the slaves involved in the process.
// A list of TFileNode(s) describes the hosts with files, each
// has a list of TFileStat(s) keeping the state for each TDSet
// element (file).
//
// The list of TSlaveStat(s) keep track of the work (being) done
// by each slave
//


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

class TPacketizer::TFileStat : public TObject {

private:
   Bool_t         fIsDone;       // is this element processed
   TFileNode     *fNode;         // my FileNode
   TDSetElement  *fElement;      // location of the file and its range
   Long64_t       fNextEntry;    // cursor in the range, -1 when done

public:
   TFileStat(TFileNode *node, TDSetElement *elem);

   Bool_t         IsDone() const {return fIsDone;}
   void           SetDone() {fIsDone = kTRUE;}
   TFileNode     *GetNode() const {return fNode;}
   TDSetElement  *GetElement() const {return fElement;}
   Long64_t       GetNextEntry() const {return fNextEntry;}
   void           MoveNextEntry(Long64_t step) {fNextEntry += step;}
};


TPacketizer::TFileStat::TFileStat(TFileNode *node, TDSetElement *elem)
   : fIsDone(kFALSE), fNode(node), fElement(elem), fNextEntry(elem->GetFirst())
{
}


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

class TPacketizer::TFileNode : public TObject {

private:
   TString        fNodeName;        // FQDN of the node
   TList         *fFiles;           // TDSetElements (files) stored on this node
   TObject       *fUnAllocFileNext; // cursor in fFiles
   TList         *fActFiles;        // files with work remaining
   TObject       *fActFileNext;     // cursor in fActFiles
   Int_t          fMySlaveCnt;      // number of slaves running on this node
   Int_t          fSlaveCnt;        // number of external slaves processing files on this node

public:
   TFileNode(const char *name);
   ~TFileNode() { delete fFiles; delete fActFiles; }

   void        IncMySlaveCnt() { fMySlaveCnt++; }
   void        IncSlaveCnt(const char *slave) { if (fNodeName != slave) fSlaveCnt++; }
   void        DecSlaveCnt(const char *slave) { if (fNodeName != slave) fSlaveCnt--; R__ASSERT(fSlaveCnt >= 0); }
   Int_t       GetSlaveCnt() const {return fMySlaveCnt + fSlaveCnt;}
   Int_t       GetNumberOfActiveFiles() const { return fActFiles->GetSize(); }
   Bool_t      IsSortable() const { return kTRUE; }

   const char *GetName() const { return fNodeName.Data(); }

   void Add(TDSetElement *elem)
   {
      TFileStat *f = new TFileStat(this,elem);
      fFiles->Add(f);
      if (fUnAllocFileNext == 0) fUnAllocFileNext = fFiles->First();
   }

   TFileStat *GetNextUnAlloc()
   {
      TObject *next = fUnAllocFileNext;

      if (next != 0) {
         // make file active
         fActFiles->Add(next);
         if (fActFileNext == 0) fActFileNext = fActFiles->First();

         // move cursor
         fUnAllocFileNext = fFiles->After(fUnAllocFileNext);
      }

      return (TFileStat *) next;
   }

   TFileStat *GetNextActive()
   {
      TObject *next = fActFileNext;

      if (fActFileNext != 0) {
         fActFileNext = fActFiles->After(fActFileNext);
         if (fActFileNext == 0) fActFileNext = fActFiles->First();
      }

      return (TFileStat *) next;
   }

   void RemoveActive(TFileStat *file)
   {
      if (fActFileNext == file) fActFileNext = fActFiles->After(file);
      fActFiles->Remove(file);
      if (fActFileNext == 0) fActFileNext = fActFiles->First();
   }

   Int_t Compare(const TObject *other) const
   {
      // Must return -1 if this is smaller than obj, 0 if objects are equal
      // and 1 if this is larger than obj.
      const TFileNode *obj = dynamic_cast<const TFileNode*>(other);
      if (!obj) {
         Error("Compare", "input is not a TPacketizer::TFileNode object");
         return 0;
      }

      Int_t myVal = GetSlaveCnt();
      Int_t otherVal = obj->GetSlaveCnt();
      if (myVal < otherVal) {
         return -1;
      } else if (myVal > otherVal) {
         return 1;
      } else {
         return 0;
      }
   }

   void Print(Option_t *) const
   {
      cout << "OBJ: " << IsA()->GetName() << "\t" << fNodeName
           << "\tMySlaveCount " << fMySlaveCnt
           << "\tSlaveCount " << fSlaveCnt << endl;
   }

   void Reset()
   {
      fUnAllocFileNext = fFiles->First();
      fActFiles->Clear();
      fActFileNext = 0;
      fSlaveCnt = 0;
      fMySlaveCnt = 0;
   }
};


TPacketizer::TFileNode::TFileNode(const char *name)
   : fNodeName(name), fFiles(new TList), fUnAllocFileNext(0),fActFiles(new TList),
     fActFileNext(0), fMySlaveCnt(0), fSlaveCnt(0)
{
   // Constructor

   fFiles->SetOwner();
   fActFiles->SetOwner(kFALSE);
}


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

class TPacketizer::TSlaveStat : public TVirtualPacketizer::TVirtualSlaveStat {

friend class TPacketizer;

private:
   TFileNode     *fFileNode;     // corresponding node or 0
   TFileStat     *fCurFile;      // file currently being processed
   TDSetElement  *fCurElem;      // TDSetElement currently being processed
   TProofProgressStatus *AddProcessed(TProofProgressStatus *st);
public:
   TSlaveStat(TSlave *slave);
   ~TSlaveStat();

   TFileNode  *GetFileNode() const { return fFileNode; }

   void        SetFileNode(TFileNode *node) { fFileNode = node; }
};


TPacketizer::TSlaveStat::TSlaveStat(TSlave *slave)
   : fFileNode(0), fCurFile(0), fCurElem(0)
{
   fSlave = slave;
   fStatus = new TProofProgressStatus();
}

//______________________________________________________________________________
TPacketizer::TSlaveStat::~TSlaveStat()
{
   // Cleanup

   SafeDelete(fStatus);
}

TProofProgressStatus *TPacketizer::TSlaveStat::AddProcessed(TProofProgressStatus *st)
{
   // Update the status info to the 'st'.
   // return the difference (*st - *fStatus)

   if (st) {
      // The entriesis not correct in 'st'
      Long64_t lastEntries = st->GetEntries() - fStatus->GetEntries();
      // The last proc time should not be added
      fStatus->SetLastProcTime(0.);
      // Get the diff
      TProofProgressStatus *diff = new TProofProgressStatus(*st - *fStatus);
      *fStatus += *diff;
      // Set the correct value
      fStatus->SetLastEntries(lastEntries);
      return diff;
   } else {
      Error("AddProcessed", "status arg undefined");
      return 0;
   }
}

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

ClassImp(TPacketizer)

//______________________________________________________________________________
TPacketizer::TPacketizer(TDSet *dset, TList *slaves, Long64_t first,
                         Long64_t num, TList *input, TProofProgressStatus *st)
            : TVirtualPacketizer(input, st)
{
   // Constructor

   PDB(kPacketizer,1) Info("TPacketizer", "Enter (first %lld, num %lld)", first, num);

   // Init pointer members
   fSlaveStats = 0;
   fPackets = 0;
   fSlaveStats = 0;
   fUnAllocated = 0;
   fActive = 0;
   fFileNodes = 0;
   fMaxPerfIdx = 1;
   fMaxSlaveCnt = 0;

   if (!fProgressStatus) {
      Error("TPacketizerAdaptive", "No progress status");
      return;
   }

   Long_t maxSlaveCnt = 0;
   if (TProof::GetParameter(input, "PROOF_MaxSlavesPerNode", maxSlaveCnt) == 0) {
      if (maxSlaveCnt < 1) {
         Warning("TPacketizer", "PROOF_MaxSlavesPerNode must be grater than 0");
         maxSlaveCnt = 0;
      }
   } else {
      // Try also with Int_t (recently supported in TProof::SetParameter)
      Int_t mxslcnt = -1;
      if (TProof::GetParameter(input, "PROOF_MaxSlavesPerNode", mxslcnt) == 0) {
         if (mxslcnt < 1) {
            Warning("TPacketizer", "PROOF_MaxSlavesPerNode must be grater than 0");
            mxslcnt = 0;
         }
         maxSlaveCnt = (Long_t) mxslcnt;
      }
   }
   if (!maxSlaveCnt)
      maxSlaveCnt = gEnv->GetValue("Packetizer.MaxWorkersPerNode", 4);
   if (maxSlaveCnt > 0) {
      fMaxSlaveCnt = maxSlaveCnt;
      PDB(kPacketizer,1)
         Info("TPacketizer", "setting max number of workers per node to %ld", fMaxSlaveCnt);
   }

   fPackets = new TList;
   fPackets->SetOwner();

   fFileNodes = new TList;
   fFileNodes->SetOwner();
   fUnAllocated = new TList;
   fUnAllocated->SetOwner(kFALSE);
   fActive = new TList;
   fActive->SetOwner(kFALSE);


   fValid = kTRUE;

   // Resolve end-point urls to optmize distribution
   // dset->Lookup(); // moved to TProofPlayerRemote::Process

   // Split into per host entries
   dset->Reset();
   TDSetElement *e;
   while ((e = (TDSetElement*)dset->Next())) {
      if (e->GetValid()) continue;

      TUrl url = e->GetFileName();

      // Map non URL filenames to dummy host
      TString host;
      if ( !url.IsValid() ||
          (strncmp(url.GetProtocol(),"root", 4) &&
           strncmp(url.GetProtocol(),"rfio", 4) &&
           strncmp(url.GetProtocol(),"file", 4)) ) {
         host = "no-host";
      } else if ( url.IsValid() && !strncmp(url.GetProtocol(),"file", 4)) {
         host = "localhost";
         url.SetProtocol("root");
      } else {
         host = url.GetHost();
      }
      // Get full name for local hosts
      if (host.Contains("localhost") || host == "127.0.0.1") {
         url.SetHost(gSystem->HostName());
         host = url.GetHostFQDN();
      }

      TFileNode *node = (TFileNode*) fFileNodes->FindObject( host );

      if (node == 0) {
         node = new TFileNode(host);
         fFileNodes->Add(node);
      }

      node->Add( e );
   }

   fSlaveStats = new TMap;
   fSlaveStats->SetOwner(kFALSE);

   TSlave *slave;
   TIter si(slaves);
   while ((slave = (TSlave*) si.Next())) {
      fSlaveStats->Add( slave, new TSlaveStat(slave) );
      fMaxPerfIdx = slave->GetPerfIdx() > fMaxPerfIdx ?
         slave->GetPerfIdx() : fMaxPerfIdx;
   }

   // Setup file & filenode structure
   Reset();
   // Optimize the number of files to be open when running on subsample
   Int_t validateMode = 0;
   Int_t gprc = TProof::GetParameter(input, "PROOF_ValidateByFile", validateMode);
   Bool_t byfile = (gprc == 0 && validateMode > 0 && num > -1) ? kTRUE : kFALSE;
   if (num > -1)
      PDB(kPacketizer,2)
         Info("TPacketizerAdaptive",
              "processing subset of entries: validating by file? %s", byfile ? "yes": "no");
   ValidateFiles(dset, slaves, num, byfile);

   if (!fValid) return;

   // apply global range (first,num) to dset and rebuild structure
   // ommitting TDSet elements that are not needed

   Int_t files = 0;
   fTotalEntries = 0;
   fUnAllocated->Clear();  // avoid dangling pointers
   fActive->Clear();
   fFileNodes->Clear();    // then delete all objects
   PDB(kPacketizer,2) Info("TPacketizer", "processing range: first %lld, num %lld", first, num);

   dset->Reset();
   Long64_t cur = 0;
   while (( e = (TDSetElement*)dset->Next())) {

      // Skip invalid or missing file; It will be moved
      // from the dset to the 'MissingFiles' list in the player.
      if (!e->GetValid()) continue;

      // The dataset name, if any
      if (fDataSet.IsNull() && e->GetDataSet() && strlen(e->GetDataSet()))
         fDataSet = e->GetDataSet();

      TUrl url = e->GetFileName();
      Long64_t eFirst = e->GetFirst();
      Long64_t eNum = e->GetNum();
      PDB(kPacketizer,2)
         Info("TPacketizer", " --> '%s'", e->GetFileName());
      PDB(kPacketizer,2)
         Info("TPacketizer", " --> first %lld, num %lld (cur %lld)", eFirst, eNum, cur);

      if (!e->GetEntryList()){
         // this element is before the start of the global range, skip it
         if (cur + eNum < first) {
            cur += eNum;
            PDB(kPacketizer,2)
               Info("TPacketizer", " --> skip element cur %lld", cur);
            continue;
         }

         // this element is after the end of the global range, skip it
         if (num != -1 && (first+num <= cur)) {
            cur += eNum;
            PDB(kPacketizer,2)
               Info("TPacketizer", " --> drop element cur %lld", cur);
            continue; // break ??
         }

         Bool_t inRange = kFALSE;
         if (cur <= first || (num != -1 && (first+num <= cur+eNum))) {

            if (cur <= first) {
               // If this element contains the start of the global range
               // adjust its start and number of entries
               e->SetFirst( eFirst + (first - cur) );
               e->SetNum( e->GetNum() - (first - cur) );
               PDB(kPacketizer,2)
                  Info("TPacketizer", " --> adjust start %lld and end %lld",
                       eFirst + (first - cur), first + num - cur);
               inRange = kTRUE;
            }
            if (num != -1 && (first+num <= cur+eNum)) {
               // If this element contains the end of the global range
               // adjust its number of entries
               e->SetNum( first + num - e->GetFirst() - cur );
               PDB(kPacketizer,2)
                  Info("TPacketizer", " --> adjust end %lld", first + num - cur);
               inRange = kTRUE;
            }

         } else {
            // Increment the counter ...
            PDB(kPacketizer,2)
               Info("TPacketizer", " --> increment 'cur' by %lld", eNum);
            cur += eNum;
         }
         // Re-adjust eNum and cur, if needed
         if (inRange) {
            cur += eNum;
            eNum = e->GetNum();
         }

      } else {
         TEntryList *enl = dynamic_cast<TEntryList *>(e->GetEntryList());
         if (enl) {
            eNum = enl->GetN();
         } else {
            TEventList *evl = dynamic_cast<TEventList *>(e->GetEntryList());
            eNum = evl ? evl->GetN() : eNum;
         }
         if (!eNum)
            continue;
      }
      PDB(kPacketizer,2)
         Info("TPacketizer", " --> next cur %lld", cur);

      // Map non URL filenames to dummy host
      TString host;
      if ( !url.IsValid() ||
          (strncmp(url.GetProtocol(),"root", 4) &&
           strncmp(url.GetProtocol(),"rfio", 4) &&
           strncmp(url.GetProtocol(),"file", 4)) ) {
         host = "no-host";
      } else if ( url.IsValid() && !strncmp(url.GetProtocol(),"file", 4)) {
         host = "localhost";
         url.SetProtocol("root");
      } else {
         host = url.GetHostFQDN();
      }
      // Get full name for local hosts
      if (host.Contains("localhost") || host == "127.0.0.1") {
         url.SetHost(gSystem->HostName());
         host = url.GetHostFQDN();
      }

      TFileNode *node = (TFileNode*) fFileNodes->FindObject( host );

      if ( node == 0 ) {
         node = new TFileNode( host );
         fFileNodes->Add( node );
      }

      ++files;
      fTotalEntries += eNum;
      node->Add(e);
      PDB(kPacketizer,2) e->Print("a");
   }

   PDB(kPacketizer,1)
      Info("TPacketizer", "processing %lld entries in %d files on %d hosts",
                         fTotalEntries, files, fFileNodes->GetSize());

   // Set the total number for monitoring
   if (gPerfStats)
      gPerfStats->SetNumEvents(fTotalEntries);

   Reset();

   if (fFileNodes->GetSize() == 0) {
      Info("TPacketizer", "no valid or non-empty file found: setting invalid");
      // No valid files: set invalid and return
      fValid = kFALSE;
      return;
   }

   // Below we provide a possibility to change the way packet size is
   // calculated or define the packet size directly.
   // fPacketAsAFraction can be interpreted as follows:
   // assuming all slaves have equal processing rate,
   // packet size is (#events processed by 1 slave) / fPacketSizeAsAFraction.
   // It substitutes 20 in the old formula to calculate the fPacketSize:
   // fPacketSize = fTotalEntries / (20 * nslaves)
   Long_t packetAsAFraction = 20;
   if (TProof::GetParameter(input, "PROOF_PacketAsAFraction", packetAsAFraction) == 0)
      Info("Process", "using alternate fraction of query time as a packet Size: %ld",
           packetAsAFraction);
   fPacketAsAFraction = (Int_t)packetAsAFraction;

   fPacketSize = 1;
   if (TProof::GetParameter(input, "PROOF_PacketSize", fPacketSize) == 0) {
      Info("Process","using alternate packet size: %lld", fPacketSize);
   } else {
      // Heuristic for starting packet size
      Int_t nslaves = fSlaveStats->GetSize();
      if (nslaves > 0) {
         fPacketSize = fTotalEntries / (fPacketAsAFraction * nslaves);
         if (fPacketSize < 1) fPacketSize = 1;
      } else {
         fPacketSize = 1;
      }
   }

   PDB(kPacketizer,1) Info("TPacketizer", "Base Packetsize = %lld", fPacketSize);

   if (!fValid)
      SafeDelete(fProgress);

   PDB(kPacketizer,1) Info("TPacketizer", "Return");
}

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

   if (fSlaveStats) {
      fSlaveStats->DeleteValues();
   }

   SafeDelete(fPackets);
   SafeDelete(fSlaveStats);
   SafeDelete(fUnAllocated);
   SafeDelete(fActive);
   SafeDelete(fFileNodes);
}

//______________________________________________________________________________
TPacketizer::TFileStat *TPacketizer::GetNextUnAlloc(TFileNode *node)
{
   // Get next unallocated file.

   TFileStat *file = 0;

   if (node != 0) {
      file = node->GetNextUnAlloc();
      if (file == 0) RemoveUnAllocNode(node);
   } else {
      while (file == 0 && ((node = NextUnAllocNode()) != 0)) {
         file = node->GetNextUnAlloc();
         if (file == 0) RemoveUnAllocNode(node);
      }
   }

   if (file != 0) {
      // if needed make node active
      if (fActive->FindObject(node) == 0) {
         fActive->Add(node);
      }
   }

   return file;
}

//______________________________________________________________________________
TPacketizer::TFileNode *TPacketizer::NextUnAllocNode()
{
   // Get next unallocated node.

   fUnAllocated->Sort();
   PDB(kPacketizer,2) {
      cout << "TPacketizer::NextUnAllocNode()" << endl;
      fUnAllocated->Print();
   }

   TFileNode *fn = (TFileNode*) fUnAllocated->First();
   if (fn != 0 && fMaxSlaveCnt > 0 && fn->GetSlaveCnt() >= fMaxSlaveCnt) {
      PDB(kPacketizer,1) Info("NextUnAllocNode", "reached workers per node limit (%ld)",
                              fMaxSlaveCnt);
      fn = 0;
   }

   return fn;
}

//______________________________________________________________________________
void TPacketizer::RemoveUnAllocNode(TFileNode * node)
{
   // Remove unallocated node.

   fUnAllocated->Remove(node);
}

//______________________________________________________________________________
TPacketizer::TFileStat *TPacketizer::GetNextActive()
{
   // Get next active file.

   TFileNode *node;
   TFileStat *file = 0;

   while (file == 0 && ((node = NextActiveNode()) != 0)) {
         file = node->GetNextActive();
         if (file == 0) RemoveActiveNode(node);
   }

   return file;
}

//______________________________________________________________________________
TPacketizer::TFileNode *TPacketizer::NextActiveNode()
{
   // Get next active node.

   fActive->Sort();
   PDB(kPacketizer,2) {
      cout << "TPacketizer::NextActiveNode()" << endl;
      fActive->Print();
   }

   TFileNode *fn = (TFileNode*) fActive->First();
   if (fn != 0 && fMaxSlaveCnt > 0 && fn->GetSlaveCnt() >= fMaxSlaveCnt) {
      PDB(kPacketizer,1) Info("NextActiveNode", "reached workers per node limit (%ld)", fMaxSlaveCnt);
      fn = 0;
   }

   return fn;
}

//______________________________________________________________________________
void TPacketizer::RemoveActive(TFileStat *file)
{
   // Remove file from the list of actives.

   TFileNode *node = file->GetNode();

   node->RemoveActive(file);
   if (node->GetNumberOfActiveFiles() == 0) RemoveActiveNode(node);
}

//______________________________________________________________________________
void TPacketizer::RemoveActiveNode(TFileNode *node)
{
   // Remove node from the list of actives.

   fActive->Remove(node);
}

//______________________________________________________________________________
void TPacketizer::Reset()
{
   // Reset the internal datastructure for packet distribution.

   fUnAllocated->Clear();
   fUnAllocated->AddAll(fFileNodes);

   fActive->Clear();

   TIter files(fFileNodes);
   TFileNode *fn;
   while ((fn = (TFileNode*) files.Next()) != 0) {
      fn->Reset();
   }

   TIter slaves(fSlaveStats);
   TObject *key;
   while ((key = slaves.Next()) != 0) {
      TSlaveStat *slstat = (TSlaveStat*) fSlaveStats->GetValue(key);
      if (slstat) {
         fn = (TFileNode*) fFileNodes->FindObject(slstat->GetName());
         if (fn != 0 ) {
            slstat->SetFileNode(fn);
            fn->IncMySlaveCnt();
         }
         slstat->fCurFile = 0;
      } else {
         Warning("Reset", "TSlaveStat associated to key '%s' is NULL", key->GetName());
      }
   }
}

//______________________________________________________________________________
void TPacketizer::ValidateFiles(TDSet *dset, TList *slaves, Long64_t maxent, Bool_t byfile)
{
   // Check existence of file/dir/tree an get number of entries.
   // Assumes the files have been setup.

   TMap     slaves_by_sock;
   TMonitor mon;
   TList    workers;


   // Setup the communication infrastructure

   workers.AddAll(slaves);
   TIter    si(slaves);
   TSlave  *slm = 0;
   while ((slm = (TSlave*)si.Next()) != 0) {
      PDB(kPacketizer,3)
         Info("ValidateFiles","socket added to monitor: %p (%s)",
              slm->GetSocket(), slm->GetName());
      mon.Add(slm->GetSocket());
      slaves_by_sock.Add(slm->GetSocket(), slm);
      PDB(kPacketizer,1)
         Info("ValidateFiles",
              "mon: %p, wrk: %p, sck: %p", &mon, slm, slm->GetSocket());
   }

   mon.DeActivateAll();

   ((TProof*)gProof)->DeActivateAsyncInput();

   // Some monitoring systems (TXSocketHandler) need to know this
   ((TProof*)gProof)->fCurrentMonitor = &mon;

   // Preparing for client notification
   TString msg("Validating files");
   UInt_t n = 0;
   UInt_t tot = dset->GetListOfElements()->GetSize();
   Bool_t st = kTRUE;

   Long64_t totent = 0, nopenf = 0;
   while (kTRUE) {

      // send work
      while( TSlave *s = (TSlave*)workers.First() ) {

         workers.Remove(s);

         // find a file

         TSlaveStat *slstat = (TSlaveStat*)fSlaveStats->GetValue(s);
         if (!slstat) {
            Error("ValidateFiles", "TSlaveStat associated to slave '%s' is NULL", s->GetName());
            continue;
         }
         TFileNode *node = 0;
         TFileStat *file = 0;

         // try its own node first
         if ( (node = slstat->GetFileNode()) != 0 ) {
            file = GetNextUnAlloc(node);
            if ( file == 0 ) {
               slstat->SetFileNode(0);
            }
         }

         // look for a file on any other node if necessary
         if (file == 0) {
            file = GetNextUnAlloc();
         }

         if ( file != 0 ) {
            // files are done right away
            RemoveActive(file);

            slstat->fCurFile = file;
            TDSetElement *elem = file->GetElement();
            Long64_t entries = elem->GetEntries(kTRUE, kFALSE);
            if (entries < 0 || strlen(elem->GetTitle()) <= 0) {
               // This is decremented when we get the reply
               file->GetNode()->IncSlaveCnt(slstat->GetName());
               TMessage m(kPROOF_GETENTRIES);
               m << dset->IsTree()
               << TString(elem->GetFileName())
               << TString(elem->GetDirectory())
               << TString(elem->GetObjName());

               s->GetSocket()->Send( m );
               mon.Activate(s->GetSocket());
               PDB(kPacketizer,2)
                  Info("ValidateFiles",
                       "sent to worker-%s (%s) via %p GETENTRIES on %s %s %s %s",
                       s->GetOrdinal(), s->GetName(), s->GetSocket(),
                       dset->IsTree() ? "tree" : "objects", elem->GetFileName(),
                       elem->GetDirectory(), elem->GetObjName());
            } else {
               // Fill the info
               elem->SetTDSetOffset(entries);
               if (entries > 0) {
                  // Most likely valid
                  elem->SetValid();
                  if (!elem->GetEntryList()) {
                     if (elem->GetFirst() > entries) {
                        Error("ValidateFiles",
                              "first (%lld) higher then number of entries (%lld) in %s",
                              elem->GetFirst(), entries, elem->GetFileName());
                        // disable element
                        slstat->fCurFile->SetDone();
                        elem->Invalidate();
                        dset->SetBit(TDSet::kSomeInvalid);
                     }
                     if (elem->GetNum() == -1) {
                        elem->SetNum(entries - elem->GetFirst());
                     } else if (elem->GetFirst() + elem->GetNum() > entries) {
                        Warning("ValidateFiles", "num (%lld) + first (%lld) larger then number of"
                                 " keys/entries (%lld) in %s", elem->GetNum(), elem->GetFirst(),
                                 entries, elem->GetFileName());
                        elem->SetNum(entries - elem->GetFirst());
                     }
                     PDB(kPacketizer,2)
                        Info("ValidateFiles",
                             "found elem '%s' with %lld entries", elem->GetFileName(), entries);
                  }
               }
               // Notify the client
               n++;
               gProof->SendDataSetStatus(msg, n, tot, st);

               // This worker is ready for the next validation
               workers.Add(s);
            }
         }
      }

      // Check if there is anything to wait for
      if (mon.GetActive() == 0) {
         if (byfile && maxent > 0) {
            // How many files do we still need ?
            Long64_t nrestf = (maxent - totent) * nopenf / totent ;
            if (nrestf <= 0 && maxent > totent) nrestf = 1;
            if (nrestf > 0) {
               PDB(kPacketizer,3)
                  Info("ValidateFiles", "{%lld, %lld, %lld): needs to validate %lld more files",
                                         maxent, totent, nopenf, nrestf);
               si.Reset();
               while ((slm = (TSlave *) si.Next()) && nrestf--) {
                  workers.Add(slm);
               }
               continue;
            } else {
               PDB(kPacketizer,3)
                  Info("ValidateFiles", "no need to validate more files");
               break;
            }
         } else {
            break;
         }
      }

      PDB(kPacketizer,3) {
         Info("ValidateFiles", "waiting for %d workers:", mon.GetActive());
         TList *act = mon.GetListOfActives();
         TIter next(act);
         TSocket *s = 0;
         while ((s = (TSocket*) next())) {
            Info("ValidateFiles", "found sck: %p", s);
            TSlave *sl = (TSlave *) slaves_by_sock.GetValue(s);
            if (sl)
               Info("ValidateFiles", "   worker-%s (%s)", sl->GetOrdinal(), sl->GetName());
         }
         delete act;
      }

      TSocket *sock = mon.Select();
      // If we have been interrupted break
      if (!sock) {
         Error("ValidateFiles", "selection has been interrupted - STOP");
         mon.DeActivateAll();
         fValid = kFALSE;
         break;
      }
      mon.DeActivate(sock);

      PDB(kPacketizer,3) Info("ValidateFiles", "select returned: %p", sock);

      TSlave *slave = (TSlave *) slaves_by_sock.GetValue( sock );
      if (!sock->IsValid()) {
         // A socket got invalid during validation
         Error("ValidateFiles", "worker-%s (%s) got invalid - STOP",
               slave->GetOrdinal(), slave->GetName());
         ((TProof*)gProof)->MarkBad(slave);
         fValid = kFALSE;
         break;
      }

      TMessage *reply;

      if ( sock->Recv(reply) <= 0 ) {
         // Help! lost a slave?
         ((TProof*)gProof)->MarkBad(slave);
         fValid = kFALSE;
         Error("ValidateFiles", "Recv failed! for worker-%s (%s)",
               slave->GetOrdinal(), slave->GetName());
         continue;
      }

      if (reply->What() != kPROOF_GETENTRIES) {
         // Not what we want: handover processing to the central machinery
         Int_t what = reply->What();
         ((TProof*)gProof)->HandleInputMessage(slave, reply);
         if (what == kPROOF_FATAL) {
             Error("ValidateFiles", "kPROOF_FATAL from worker-%s (%s)",
                                    slave->GetOrdinal(), slave->GetName());
             fValid = kFALSE;
         } else {
            // Reactivate the socket
            mon.Activate(sock);
         }
         // Get next message
         continue;
      }

      TSlaveStat *slavestat = (TSlaveStat*) fSlaveStats->GetValue( slave );
      TDSetElement *e = slavestat->fCurFile->GetElement();
      slavestat->fCurFile->GetNode()->DecSlaveCnt(slavestat->GetName());
      Long64_t entries;

      (*reply) >> entries;

      // Extract object name, if there
      if ((reply->BufferSize() > reply->Length())) {
         TString objname;
         (*reply) >> objname;
         e->SetTitle(objname);
      }

      e->SetTDSetOffset(entries);
      if ( entries > 0 ) {

         // This dataset element is most likely valid
         e->SetValid();

         //if (!e->GetEventList()) {
         if (!e->GetEntryList()){
            if ( e->GetFirst() > entries ) {
               Error("ValidateFiles", "first (%lld) higher then number of entries (%lld) in %s",
                                      e->GetFirst(), entries, e->GetFileName());

               // Invalidate the element
               slavestat->fCurFile->SetDone();
               e->Invalidate();
               dset->SetBit(TDSet::kSomeInvalid);
            }

            if ( e->GetNum() == -1 ) {
               e->SetNum( entries - e->GetFirst() );
            } else if ( e->GetFirst() + e->GetNum() > entries ) {
               Error("ValidateFiles",
                     "num (%lld) + first (%lld) larger then number of keys/entries (%lld) in %s",
                     e->GetNum(), e->GetFirst(), entries, e->GetFileName());
               e->SetNum(entries - e->GetFirst());
            }
         }

         // Count
         totent += entries;
         nopenf++;

         // Notify the client
         n++;
         gProof->SendDataSetStatus(msg, n, tot, st);

      } else {

         Error("ValidateFiles", "cannot get entries for %s (", e->GetFileName() );
         //
         // Need to fix this with a user option to allow incomplete file sets (rdm)
         //
         //fValid = kFALSE; // all element must be readable!
         if (gProofServ) {
            TMessage m(kPROOF_MESSAGE);
            m << TString(Form("Cannot get entries for file: %s - skipping", e->GetFileName()));
            gProofServ->GetSocket()->Send(m);
         }

         // Invalidate the element
         e->Invalidate();
         dset->SetBit(TDSet::kSomeInvalid);
      }
      PDB(kPacketizer,3) Info("ValidateFiles", " %lld events validated", totent);

      // Ready for the next job, unless we have enough files
      if (maxent < 0 || ((totent < maxent) && !byfile))
         workers.Add(slave);
   }

   // report std. output from slaves??

   ((TProof*)gProof)->ActivateAsyncInput();

   // This needs to be reset
   ((TProof*)gProof)->fCurrentMonitor = 0;

   // No reason to continue if invalid
   if (!fValid)
      return;


   // compute the offset for each file element
   Long64_t offset = 0;
   Long64_t newOffset = 0;
   TIter next(dset->GetListOfElements());
   TDSetElement *el;
   while ( (el = dynamic_cast<TDSetElement*> (next())) ) {
      newOffset = offset + el->GetTDSetOffset();
      el->SetTDSetOffset(offset);
      offset = newOffset;
   }
}

//______________________________________________________________________________
Long64_t TPacketizer::GetEntriesProcessed(TSlave *slave) const
{
   // Get entries processed by the specified slave.

   if ( fSlaveStats == 0 ) return 0;

   TSlaveStat *slstat = (TSlaveStat*) fSlaveStats->GetValue( slave );

   if ( slstat == 0 ) return 0;

   return slstat->GetEntriesProcessed();
}

//______________________________________________________________________________
Float_t TPacketizer::GetCurrentRate(Bool_t &all)
{
   // Get Estimation of the current rate; just summing the current rates of
   // the active workers

   all = kTRUE;
   // Loop over the workers
   Float_t currate = 0.;
   if (fSlaveStats && fSlaveStats->GetSize() > 0) {
      TIter nxw(fSlaveStats);
      TObject *key;
      while ((key = nxw()) != 0) {
         TSlaveStat *slstat = (TSlaveStat *) fSlaveStats->GetValue(key);
         if (slstat && slstat->GetProgressStatus() && slstat->GetEntriesProcessed() > 0) {
            // Sum-up the current rates
            currate += slstat->GetProgressStatus()->GetCurrentRate();
         } else {
            all = kFALSE;
         }
      }
   }
   // Done
   return currate;
}

//______________________________________________________________________________
TDSetElement *TPacketizer::GetNextPacket(TSlave *sl, TMessage *r)
{
   // Get next packet

   if ( !fValid ) {
      return 0;
   }

   // find slave

   TSlaveStat *slstat = (TSlaveStat*) fSlaveStats->GetValue( sl );

   R__ASSERT( slstat != 0 );

   // update stats & free old element

   Bool_t firstPacket = kFALSE;
   if ( slstat->fCurElem != 0 ) {
      Double_t latency = 0., proctime = 0., proccpu = 0.;
      Long64_t bytesRead = -1;
      Long64_t totalEntries = -1;
      Long64_t totev = 0;
      Long64_t numev = slstat->fCurElem->GetNum();

      fPackets->Add(slstat->fCurElem);

      if (sl->GetProtocol() > 18) {
         TProofProgressStatus *status = 0;
         (*r) >> latency;
         (*r) >> status;

         // Calculate the progress made in the last packet
         TProofProgressStatus *progress = 0;
         if (status) {
            // upadte the worker status
            numev = status->GetEntries() - slstat->GetEntriesProcessed();
            progress = slstat->AddProcessed(status);
            if (progress) {
               // (*fProgressStatus) += *progress;
               proctime = progress->GetProcTime();
               proccpu  = progress->GetCPUTime();
               totev  = status->GetEntries(); // for backward compatibility
               bytesRead  = progress->GetBytesRead();
               delete progress;
            }
            delete status;
         } else
             Error("GetNextPacket", "no status came in the kPROOF_GETPACKET message");
      } else {

         (*r) >> latency >> proctime >> proccpu;

         // only read new info if available
         if (r->BufferSize() > r->Length()) (*r) >> bytesRead;
         if (r->BufferSize() > r->Length()) (*r) >> totalEntries;
         if (r->BufferSize() > r->Length()) (*r) >> totev;

         numev = totev - slstat->GetEntriesProcessed();
         slstat->GetProgressStatus()->IncEntries(numev);
         slstat->GetProgressStatus()->IncBytesRead(bytesRead);
      }

      if (fProgressStatus) {
         if (numev > 0)  fProgressStatus->IncEntries(numev);
         if (bytesRead > 0)  fProgressStatus->IncBytesRead(bytesRead);
      }
      PDB(kPacketizer,2)
         Info("GetNextPacket","worker-%s (%s): %lld %7.3lf %7.3lf %7.3lf %lld",
                              sl->GetOrdinal(), sl->GetName(),
                              numev, latency, proctime, proccpu, bytesRead);

      if (gPerfStats)
         gPerfStats->PacketEvent(sl->GetOrdinal(), sl->GetName(), slstat->fCurElem->GetFileName(),
                                 numev, latency, proctime, proccpu, bytesRead);

      slstat->fCurElem = 0;
      if (fProgressStatus && fProgressStatus->GetEntries() == fTotalEntries) {
         HandleTimer(0);   // Send last timer message
         delete fProgress; fProgress = 0;
      }
   } else {
      firstPacket = kTRUE;
   }

   if ( fStop ) {
      HandleTimer(0);
      return 0;
   }

   // get a file if needed

   TFileStat *file = slstat->fCurFile;

   if ( file != 0 && file->IsDone() ) {
      file->GetNode()->DecSlaveCnt(slstat->GetName());
      if (gPerfStats)
         gPerfStats->FileEvent(sl->GetOrdinal(), sl->GetName(), file->GetNode()->GetName(),
                               file->GetElement()->GetFileName(), kFALSE);
      file = 0;
   }
   // Reset the current file field
   slstat->fCurFile = file;

   if (!file) {

      // Try its own node first
      if (slstat->GetFileNode() != 0) {
         file = GetNextUnAlloc(slstat->GetFileNode());
         if (!file) {
            slstat->SetFileNode(0);
         }
      }

      // try to find an unused filenode first
      if (!file) {
         file = GetNextUnAlloc();
      }

      // then look at the active filenodes
      if (!file) {
         file = GetNextActive();
      }

      if (!file) return 0;

      slstat->fCurFile = file;
      file->GetNode()->IncSlaveCnt(slstat->GetName());
      if (gPerfStats)
         gPerfStats->FileEvent(sl->GetOrdinal(), sl->GetName(),
                               file->GetNode()->GetName(),
                               file->GetElement()->GetFileName(), kTRUE);
   }

   // get a packet

   TDSetElement *base = file->GetElement();
   Long64_t num = Long64_t(fPacketSize*(Float_t)slstat->fSlave->GetPerfIdx()/fMaxPerfIdx);
   if (num < 1) num = 1;

   Long64_t first = file->GetNextEntry();
   Long64_t last = base->GetFirst() + base->GetNum();

   if ( first + num >= last ) {
      num = last - first;
      file->SetDone(); // done

      // delete file from active list (unalloc list is single pass, no delete needed)
      RemoveActive(file);

   } else {
      file->MoveNextEntry(num);
   }


   slstat->fCurElem = CreateNewPacket(base, first, num);
   if (base->GetEntryList())
      slstat->fCurElem->SetEntryList(base->GetEntryList(), first, num);

   // Flag the first packet of a new run (dataset)
   if (firstPacket)
      slstat->fCurElem->SetBit(TDSetElement::kNewRun);
   else
      slstat->fCurElem->ResetBit(TDSetElement::kNewRun);

   PDB(kPacketizer,2)
      Info("GetNextPacket","%s: %s %lld %lld", sl->GetOrdinal(), base->GetFileName(), first, num);

   return slstat->fCurElem;
}

//______________________________________________________________________________
Int_t TPacketizer::GetActiveWorkers()
{
   // Return the number of workers still processing

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