ROOT logo
// @(#)root/tree:$Id: TTreeCacheUnzip.cxx 23878 2008-05-16 14:35:09Z brun $
// Author: Leandro Franco   10/04/2008

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

//////////////////////////////////////////////////////////////////////////
// Parallel Unzipping                                                   //
//                                                                      //
// TTreeCache has been modified to create an additional thread to unzip //
// the buffers that are sitting on the cache, in that way we could      //
// improve the overall ROOT performance by executing two tasks in       //
// parallel.                                                            //
// The order is important and for the moment we will do it following    //
// the sorting algorithm in TTreeCache since they are usually read by   //
// entry.                                                               //
// By default the unzipping cache will need only 10% of the buffer for  //
// TTreCache so be careful with the memory (in a normal case you need   //
// 10MB for TTreeCache and 1MB for the unizp. buffer), to change it use //
// TTreeCache::SetUnzipBufferSize(Long64_t bufferSize)                  //
// where bufferSize must be passed in bytes.                            //
//                                                                      //
// This is a implemented in a similar way to a consumer-producer model  //
// where the the producer will be TTreCache by transfering the data     //
// and the consumer will be additional Thread trying to unzip it.       //
//////////////////////////////////////////////////////////////////////////

#include "TTreeCacheUnzip.h"
#include "TChain.h"
#include "TBranch.h"
#include "TFile.h"
#include "TEventList.h"
#include "TVirtualMutex.h"
#include "TThread.h"
#include "TCondition.h"
#include "TMath.h"
#include "Bytes.h"

extern "C" void R__unzip(Int_t *nin, UChar_t *bufin, Int_t *lout, char *bufout, Int_t *nout);

 TTreeCacheUnzip::EParUnzipMode TTreeCacheUnzip::fgParallel = TTreeCacheUnzip::kDisable;

// Unzip cache is 10% of TTreeCache.
// if by default fBufferSize = 10MB
// then 0.1=1MB 0.01=100KB 0.001=10KB 0.0001=1KB
Double_t TTreeCacheUnzip::fgRelBuffSize = 0.2;

ClassImp(TTreeCacheUnzip)

//______________________________________________________________________________
TTreeCacheUnzip::TTreeCacheUnzip() : TTreeCache(),
   fUnzipThread(0),
   fActiveThread(kFALSE),
   fNewTransfer(kFALSE),
   fTmpBufferSz(0),
   fTmpBuffer(0),
   fPosWrite(0),
   fUnzipLen(0),
   fUnzipPos(0),
   fNseekMax(0),
   fUnzipBufferSize(0),
   fUnzipBuffer(0),
   fSkipZip(0),
   fUnzipStart(0),
   fUnzipEnd(0),
   fUnzipNext(0),
   fNUnzip(0),
   fNFound(0),
   fNMissed(0)
{
   // Default Constructor.

   Init();
}

//______________________________________________________________________________
TTreeCacheUnzip::TTreeCacheUnzip(TTree *tree, Int_t buffersize) : TTreeCache(tree,buffersize),
   fUnzipThread(0),
   fActiveThread(kFALSE),
   fNewTransfer(kFALSE),
   fTmpBufferSz(10000),
   fTmpBuffer(new char[fTmpBufferSz]),
   fPosWrite(0),
   fUnzipLen(0),
   fUnzipPos(0),
   fNseekMax(0),
   fUnzipBufferSize(0),
   fUnzipBuffer(0),
   fSkipZip(0),
   fUnzipStart(0),
   fUnzipEnd(0),
   fUnzipNext(0),
   fNUnzip(0),
   fNFound(0),
   fNMissed(0)
{
   // Constructor.

   Init();
}

//______________________________________________________________________________
void TTreeCacheUnzip::Init()
{
   // Initialization procedure common to all the constructors

   fMutexCache       = new TMutex(kTRUE);
   fMutexBuffer      = new TMutex();
   fMutexList        = new TMutex();
   fUnzipCondition   = new TCondition();

   if (fgParallel == kDisable) {
      fParallel = kFALSE;
   }
   else if(fgParallel == kEnable || fgParallel == kForce) {
      SysInfo_t info;
      gSystem->GetSysInfo(&info);
      Int_t ncpus = info.fCpus;

      if(ncpus > 1 || fgParallel == kForce) {
         if(gDebug > 0)
            Info("TTreeCacheUnzip", "Enabling Parallel Unzipping, number of cpus:%d", ncpus);

         fParallel = kTRUE;
         StartThreadUnzip();
      }
      else {
         fParallel = kFALSE;
      }
   }
   else {
      Warning("TTreeCacheUnzip", "Parallel Option unknown");
   }
}

//______________________________________________________________________________
TTreeCacheUnzip::~TTreeCacheUnzip()
{
   // destructor. (in general called by the TFile destructor
   // destructor. (in general called by the TFile destructor)

   //ResetCache();

   if (IsActiveThread())
      StopThreadUnzip();

   delete fMutexCache;
   delete fMutexBuffer;
   delete fMutexList;

   delete [] fUnzipBuffer;
   delete [] fTmpBuffer;
   delete [] fUnzipLen;
   delete [] fUnzipPos;
   delete fUnzipCondition;
}

//_____________________________________________________________________________
void TTreeCacheUnzip::AddBranch(TBranch *b, Bool_t subbranches /*= kFALSE*/)
{
   //add a branch to the list of branches to be stored in the cache
   //this function is called by TBranch::GetBasket
   R__LOCKGUARD(fMutexCache);

   TTreeCache::AddBranch(b, subbranches);
}

//_____________________________________________________________________________
void TTreeCacheUnzip::AddBranch(const char *branch, Bool_t subbranches /*= kFALSE*/)
{
   //add a branch to the list of branches to be stored in the cache
   //this function is called by TBranch::GetBasket
   R__LOCKGUARD(fMutexCache);

   TTreeCache::AddBranch(branch, subbranches);
}

//_____________________________________________________________________________
Bool_t TTreeCacheUnzip::FillBuffer()
{
   // Fill the cache buffer with the branches in the cache.
   R__LOCKGUARD(fMutexCache);

   //return TTreeCache::FillBuffer();

   if (fNbranches <= 0) return kFALSE;
   TTree *tree = ((TBranch*)fBranches->UncheckedAt(0))->GetTree();
   Long64_t entry = tree->GetReadEntry();

   if (!fIsManual && entry < fEntryNext) return kFALSE;

   // Triggered by the user, not the learning phase
   if (entry == -1)  entry=0;

   // Estimate number of entries that can fit in the cache compare it
   // to the original value of fBufferSize not to the real one
   if (fZipBytes==0) {
      fEntryNext = entry + tree->GetEntries();
   } else {
      fEntryNext = entry + tree->GetEntries()*fBufferSizeMin/fZipBytes;
   }
   if (fEntryMax <= 0) fEntryMax = tree->GetEntries();
   if (fEntryNext > fEntryMax) fEntryNext = fEntryMax+1;

   //check if owner has a TEventList set. If yes we optimize for this special case
   //reading only the baskets containing entries in the list
   Long64_t chainOffset = 0;
   if (fOwner->GetEventList()) {
      if (fOwner->IsA() == TChain::Class()) {
         TChain *chain = (TChain*)fOwner;
         Int_t t = chain->GetTreeNumber();
         chainOffset = chain->GetTreeOffset()[t];
      }
   }

   fMutexCache->UnLock();
   //clear cache buffer
   ResetCache();
   TFileCacheRead::Prefetch(0,0);
   fMutexCache->Lock();
   //store baskets
   Bool_t mustBreak = kFALSE;
   for (Int_t i=0;i<fNbranches;i++) {
      if (mustBreak) break;
      TBranch *b = (TBranch*)fBranches->UncheckedAt(i);
      Int_t nb = b->GetMaxBaskets();
      Int_t *lbaskets   = b->GetBasketBytes();
      Long64_t *entries = b->GetBasketEntry();
      if (!lbaskets || !entries) continue;
      //we have found the branch. We now register all its baskets
      //from the requested offset to the basket below fEntrymax
      for (Int_t j=0;j<nb;j++) {
         // This basket has already been read, skip it
         if (b->GetListOfBaskets()->UncheckedAt(j)) continue;

         Long64_t pos = b->GetBasketSeek(j);
         Int_t len = lbaskets[j];
         if (pos <= 0 || len <= 0) continue;
         if (entries[j] > fEntryNext) continue;
         if (entries[j] < entry && (j<nb-1 && entries[j+1] < entry)) continue;
         if (fOwner->GetEventList()) {
            Long64_t emax = fEntryMax;
            if (j<nb-1) emax = entries[j+1]-1;
            if (!(fOwner->GetEventList())->ContainsRange(entries[j]+chainOffset,emax+chainOffset)) continue;
         }
         fNReadPref++;
         TFileCacheRead::Prefetch(pos,len);
         //we allow up to twice the default buffer size. When using eventlist in particular
         //it may happen that the evaluation of fEntryNext is bad, hence this protection
         if (fNtot > 2*fBufferSizeMin) {TFileCacheRead::Prefetch(0,0);mustBreak = kTRUE; break;}
      }
      if (gDebug > 0) printf("Entry: %lld, registering baskets branch %s, fEntryNext=%lld, fNseek=%d, fNtot=%d\n",entry,((TBranch*)fBranches->UncheckedAt(i))->GetName(),fEntryNext,fNseek,fNtot);
   }
   fIsLearning = kFALSE;
   if (mustBreak) return kFALSE;
   return kTRUE;
}

//_____________________________________________________________________________
void TTreeCacheUnzip::SetEntryRange(Long64_t emin, Long64_t emax)
{
   // Set the minimum and maximum entry number to be processed
   // this information helps to optimize the number of baskets to read
   // when prefetching the branch buffers.
   R__LOCKGUARD(fMutexCache);

   TTreeCache::SetEntryRange(emin, emax);
}

//_____________________________________________________________________________
void TTreeCacheUnzip::StopLearningPhase()
{
   // It's the same as TTreeCache::StopLearningPhase but we guarantee that
   // we start the unzipping just after getting the buffers

   TTreeCache::StopLearningPhase();
   this->SendSignal();
}

//_____________________________________________________________________________
void TTreeCacheUnzip::UpdateBranches(TTree *tree, Bool_t owner)
{
   //update pointer to current Tree and recompute pointers to the branches in the cache
   R__LOCKGUARD(fMutexCache);

   TTreeCache::UpdateBranches(tree, owner);
}

///////////////////////////////////////////////////////////////////////////////
//                                                                           //
// From now on we have the method concerning the threading part of the cache //
//                                                                           //
///////////////////////////////////////////////////////////////////////////////

//_____________________________________________________________________________
TTreeCacheUnzip::EParUnzipMode TTreeCacheUnzip::GetParallelUnzip()
{
   // Static function that returns the parallel option
   // (to indicate an additional thread)

   return fgParallel;
}

//_____________________________________________________________________________
Bool_t TTreeCacheUnzip::IsParallelUnzip()
{
   // Static function that tells wether the multithreading unzipping
   // is activated

   if (fgParallel == kEnable || fgParallel == kForce)
      return kTRUE;

   return kFALSE;
}

//_____________________________________________________________________________
Bool_t TTreeCacheUnzip::IsActiveThread()
{
   // This indicates if the thread is active in this moment...
   // this variable is very important because if we change it from true to
   // false the thread will stop... ( see StopThreadTreeCacheUnzip() )

   return fActiveThread;
}

//_____________________________________________________________________________
Bool_t TTreeCacheUnzip::IsQueueEmpty()
{
   // It says if the queue is empty... useful to see if we have to process
   // it.
   R__LOCKGUARD(fMutexCache);

   if ( fIsLearning )
      return kTRUE;

   return kFALSE;
}

//_____________________________________________________________________________
Int_t TTreeCacheUnzip::ProcessQueue()
{
   // This will traverse the queue and read all the buffers to put them
   // in the cache... after reading each buffer it will send a signal and
   // if someone is waiting for it, it will wake up and will check the queue
   // again to see if the buffer it was waiting for was the buffer that was
   // just processed.
   // It works that way because I can not have one signal per-buffer...
   // instead there is only one signal and all the methods waiting for buffer
   // will know that a "new" buffer has been processed (even if that particular
   // method is not the one waiting for the buffer)

   if ( IsQueueEmpty() )
      return 0;

   if (gDebug > 0) Info("ProcessQueue", " Calling UnzipCache() ");

   return UnzipCache();
}

//_____________________________________________________________________________
void TTreeCacheUnzip::SendSignal()
{
   // This will send the signal corresponfing to the queue... normally used
   // when we want to start processing the list of buffers.

   if (gDebug > 0) Info("SendSignal", " fUnzipCondition->Signal()");

   fUnzipCondition->Signal();
}

//_____________________________________________________________________________
Int_t TTreeCacheUnzip::SetParallelUnzip(TTreeCacheUnzip::EParUnzipMode option)
{
   // Static function that(de)activates multithreading unzipping
   // The possible options are:
   // kEnable _Enable_ it, which causes an automatic detection and launches the
   // additional thread if the number of cores in the machine is greater than one
   // kDisable _Disable_ will not activate the additional thread.
   // kForce _Force_ will start the additional thread even if there is only one core.
   // the default will be taken as kEnable.
   // returns 0 if there was an error, 1 otherwise.

   if(fgParallel == kEnable || fgParallel == kForce || fgParallel == kDisable) {
      fgParallel = option;
      return 1;
   }
   return 0;
}

//_____________________________________________________________________________
Int_t TTreeCacheUnzip::StartThreadUnzip()
{
   // The Thread is only a part of the TTreeCache but it is the part that
   // waits for info in the queue and process it... unfortunatly, a Thread is
   // not an object an we have to deal with it in the old C-Style way
   // Returns 0 if the thread was initialized or 1 if it was already running

   if(!fUnzipThread) {
      fActiveThread=kTRUE;
      fUnzipThread= new TThread("UnzipLoop", UnzipLoop, (void*) this);
      fUnzipThread->Run();
      return 0;
   }
   return 1;
}

//_____________________________________________________________________________
Int_t TTreeCacheUnzip::StopThreadUnzip()
{
   // To stop the thread we only need to change the value of the variable
   // fActiveThread to false and the loop will stop (of course, we will have)
   // to do the cleaning after that.
   // Note: The syncronization part is important here or we will try to delete
   //       teh object while it's still processing the queue

   if(fUnzipThread){
      fActiveThread = kFALSE;
      SendSignal();
      if (fUnzipThread->Exists()) {
         fUnzipThread->Join();
      }
      return 0;
   }
   return 1;
}

//_____________________________________________________________________________
void TTreeCacheUnzip::WaitForSignal()
{
   // This is the counter part of SendSignal() and is used to wait for a buffer
   // that is in the queue and will be processed soon (instead of making a new
   // call)

   fUnzipCondition->Wait();
}

//_____________________________________________________________________________
void* TTreeCacheUnzip::UnzipLoop(void *arg)
{
   // This is a static function.
   // This is the call that will be executed in the Thread generated by
   // StartThreadTreeCacheUnzip... what we want to do is to inflate the next
   // series of buffers leaving them in the second cache.
   // Returns 0 when it finishes

   TTreeCacheUnzip *unzipMng = (TTreeCacheUnzip *)arg;
   TThread::SetCancelOn();
   TThread::SetCancelDeferred();

   while( unzipMng->IsActiveThread() ) {
      unzipMng->ProcessQueue();
      if(!unzipMng->IsActiveThread()) break;
      unzipMng->WaitForSignal();
   }
   return (void *)0;
}

///////////////////////////////////////////////////////////////////////////////
//                                                                           //
// From now on we have the method concerning the nuzipping part of the cache //
//                                                                           //
///////////////////////////////////////////////////////////////////////////////

//_____________________________________________________________________________
Int_t TTreeCacheUnzip::GetRecordHeader(char *buf, Int_t maxbytes, Int_t &nbytes, Int_t &objlen, Int_t &keylen)
{
   // Read the logical record header from the buffer buf.
   // That must be the pointer tho the header part not the object by itself and
   // must contain data of at least maxbytes
   // Returns nread;
   // In output arguments:
   //    nbytes : number of bytes in record
   //             if negative, this is a deleted record
   //             if 0, cannot read record, wrong value of argument first
   //    objlen : uncompressed object size
   //    keylen : length of logical record header
   // Note that the arguments objlen and keylen are returned only
   // if maxbytes >=16
   // Note: This was adapted from TFile... so some things dont apply

   Version_t versionkey;
   Short_t klen;
   UInt_t datime;
   Int_t nb = 0,olen;
   Int_t nread = maxbytes;
   frombuf(buf,&nb);
   nbytes = nb;
   if (nb < 0) return nread;
   //   const Int_t headerSize = Int_t(sizeof(nb) +sizeof(versionkey) +sizeof(olen) +sizeof(datime) +sizeof(klen));
   const Int_t headerSize = 16;
   if (nread < headerSize) return nread;
   frombuf(buf, &versionkey);
   frombuf(buf, &olen);
   frombuf(buf, &datime);
   frombuf(buf, &klen);
   if (!olen) olen = nbytes-klen;
   objlen = olen;
   keylen = klen;
   return nread;
}

//_____________________________________________________________________________
void TTreeCacheUnzip::ResetCache()
{
   // This will delete the list of buffers that are in the unzipping cache
   // and will reset certain values in the cache.
   // This name is ambiguos because the method doesn't reset the whole cache,
   // only the part related to the unzipping
   // Note: This method is completely different from TTreeCache::ResetCache(),
   // in that method we were cleaning the prefetching buffer while here we
   // delete the information about the unzipping buffers
   R__LOCKGUARD(fMutexList);

   if (gDebug > 0)
      Info("GetUnzipBuffer", "Thread: %d -- Reseting the cache", TThread::SelfId());

   fUnzipStart  = fUnzipEnd = fUnzipNext = 0;
   fPosWrite    = 0;
   fNewTransfer = kTRUE;
}

//_____________________________________________________________________________
Int_t TTreeCacheUnzip::GetUnzipBuffer(char **buf, Long64_t pos, Int_t len, Bool_t *free)
{
   // We try to read a buffer that has already been unzipped
   // Returns -1 in case of read failure, 0 in case it's not in the
   // cache and n>0 in case read from cache (number of bytes copied).
   // pos and len are the original values as were passed to ReadBuffer
   // but instead we will return the inflated buffer.
   // Note!! : If *buf == 0 we will allocate the buffer and it will be the
   // responsability of the caller to free it... it is useful for example
   // to pass it to the creator of TBuffer

   if (fParallel){
      if ( fIsLearning ) {
         // We need to reset it for new transferences...
         ResetCache();
         TFileCacheRead::Prefetch(0,0);
      }
      // The modify the cache if it's in de middle of something (unzipping for example)
      R__LOCKGUARD(fMutexCache);

      // If this is the first time we get here since the last FillBuffer
      // it's probable that the information about the prefetched buffers is there
      // but it hasn't actually been transfered... Is this the best place to put it??
      if (fNseek > 0 && !fIsSorted) {
         Sort();

         // Then we use the vectored read to read everything now
         if (fFile->ReadBuffers(fBuffer,fPos,fLen,fNb)) return -1;
         fIsTransferred = kTRUE;

         // Try to start the unzipping thread since we just transfered the data
         this->SendSignal();
      }

      // be careful.. can be -1
      Int_t loc = (Int_t)TMath::BinarySearch(fNseek,fSeekSort,pos);

      if (loc >= 0 && (pos == fSeekSort[loc]) ) {
	 // We shouldn't have to "wait" so a long Lock is not be very bad for the performance
         fMutexList->Lock();

         if( (loc >= fUnzipStart) && (loc < fUnzipEnd )) {
            Long64_t locPos = fUnzipPos[loc]; // Gives the pos in the buffer
            Int_t    locLen = fUnzipLen[loc]; // Gives the size in the buffer

            fMutexBuffer->Lock();
            if(!(*buf)) {
               *buf = new char[locLen+1];
               *free = kTRUE;
            }
            memcpy(*buf,&fUnzipBuffer[locPos], locLen);

	    // We could pass the pointer to the buffer instead of allocating
            // the space and copying it. I tried that and the management needed
            // to keep track of the buffer is just too much, it's just cheaper to
            // do the copy.
	    //*buf = &fUnzipBuffer[locPos];
            //*free = kFALSE;
            fMutexBuffer->UnLock();
            fNFound++;

            // If this is the last buffer from the unzipping list,
            // send the signal to start unzipping the rest
            if((loc == fUnzipEnd - 1) && (loc == fUnzipNext - 1))
               this->SendSignal();

            // We found it and copied to the buffer... we are done
            fMutexList->UnLock();
            return locLen;
         }

         if (gDebug > 0)
            Info("GetUnzipBuffer", "NOT found in the unzip cahe fUnzipStart:%d, fUnzipEnd:%d, fUnzipNext: %d, pos:%lld, len:%d",
		 fUnzipStart, fUnzipEnd, fUnzipNext, pos, len);

         // If we are in a new batch of transfer... inform the thread in case it's sleeping
         if (loc > fUnzipNext)
            this->SendSignal();

         fMutexList->UnLock();
      }
   }

   char *comp = new char[len];
   Bool_t found = kFALSE;

   if (fNseek > 0 && !fIsSorted) {
      if (gDebug > 0)
         Info("GetUnzipBuffer", "This is a new transfer... must clean things up fNSeek:%d", fNseek);
      ResetCache();
   }

   if (TFileCacheRead::ReadBuffer(comp,pos,len) == 1){
      found = kTRUE;
   }
   if(!found) {
      //not found in cache. Do we need to fill the cache?
      Bool_t bufferFilled = FillBuffer();
      if (bufferFilled) {
         if (TFileCacheRead::ReadBuffer(comp,pos,len) == 1){
            found = kTRUE;
         }
      }
   }

   if (!found) {
      fFile->Seek(pos);
      if(fFile->ReadBuffer(comp, len)){
         Error("GetUnzipBuffer", "Thread: %d --  Error reading from TFile ... must go out", TThread::SelfId());
         delete [] comp;
         return -1;
      }
   }

   Int_t res = UnzipBuffer(buf, comp);
   *free = kTRUE;
   if (!fIsLearning) fNMissed++;

   if (comp) delete [] comp;
   return res;
}

//_____________________________________________________________________________
void TTreeCacheUnzip::SetUnzipBufferSize(Long64_t bufferSize)
{
   // Sets the size for the unzipping cache... by default it should be
   // two times the size of the prefetching cache

   fUnzipBufferSize = bufferSize;
}

//_____________________________________________________________________________
Int_t TTreeCacheUnzip::UnzipBuffer(char **dest, char *src)
{
   // UNzips a ROOT specific buffer... by reading the header at the beginning.
   // returns the size of the inflated buffer or -1 if error
   // Note!! : If *dest == 0 we will allocate the buffer and it will be the
   // responsability of the caller to free it... it is useful for example
   // to pass it to the creator of TBuffer
   // src is the original buffer with the record (header+compressed data)
   // *dest is the inflated buffer (including the header)
   Int_t  uzlen = 0;
   Bool_t alloc = kFALSE;

   // Here we read the header of the buffer
   const Int_t hlen=128;
   Int_t nbytes=0, objlen=0, keylen=0;
   GetRecordHeader(src, hlen, nbytes, objlen, keylen);

   if (gDebug > 1)
      Info("UnzipBuffer", "nbytes:%d, objlen:%d, keylen:%d  ", nbytes, objlen, keylen);

   if (!(*dest)) {
      *dest = new char[keylen+objlen];
      alloc = kTRUE;
   }
   // Must unzip the buffer
   // fSeekPos[ind]; adress of zipped buffer
   // fSeekLen[ind]; len of the zipped buffer
   // &fBuffer[fSeekPos[ind]]; memory address

   // This is similar to TBasket::ReadBasketBuffers
   Bool_t oldCase = objlen==nbytes-keylen
      && ((TBranch*)fBranches->UncheckedAt(0))->GetCompressionLevel()!=0
      && fFile->GetVersion()<=30401;

   if (objlen > nbytes-keylen || oldCase) {
      // /**/ Question? ... do we have to ask this
      //      for every buffer or the global fSkipZip is enough?
      //      can somebody else set it up?

      if (fSkipZip) {
         // Copy without unzipping
         memcpy(*dest, src, keylen);
         uzlen += keylen;

         memcpy(*dest, src + keylen, objlen);
         uzlen += objlen;

         return nbytes;
      }

      // Copy the key
      if (gDebug > 2)
         Info("UnzipBuffer", "Copy the key keylen:%d from src:%p to *dest:%p", keylen, src, *dest);

      memcpy(*dest, src, keylen);
      uzlen += keylen;

      char *objbuf = *dest + keylen;
      UChar_t *bufcur = (UChar_t *) (src + keylen);
      Int_t nin, nout, nbuf;
      Int_t noutot = 0;

      while (1) {
         nin  = 9 + ((Int_t)bufcur[3] | ((Int_t)bufcur[4] << 8) | ((Int_t)bufcur[5] << 16));
         nbuf = (Int_t)bufcur[6] | ((Int_t)bufcur[7] << 8) | ((Int_t)bufcur[8] << 16);

         if (gDebug > 2)
            Info("UnzipBuffer", " nin:%d, nbuf:%d, bufcur[3] :%d, bufcur[4] :%d, bufcur[5] :%d ",
                 nin, nbuf, bufcur[3], bufcur[4], bufcur[5]);

         if (oldCase && (nin > objlen || nbuf > objlen)) {
            if (gDebug > 2)
               Info("UnzipBuffer", "oldcase objlen :%d ", objlen);

            //buffer was very likely not compressed in an old version
            memcpy( *dest + keylen, src + keylen, objlen);
            uzlen += objlen;
            return uzlen;
         }

         R__unzip(&nin, bufcur, &nbuf, objbuf, &nout);
         if (gDebug > 2)
            Info("UnzipBuffer", "R__unzip nin:%d, bufcur:%p, nbuf:%d, objbuf:%p, nout:%d",
                 nin, bufcur, nbuf, objbuf, nout);

         if (!nout) break;
         noutot += nout;
         if (noutot >= objlen) break;
         bufcur += nin;
         objbuf += nout;
      }

      if (noutot != objlen) {
         Error("UnzipBuffer", "nbytes = %d, keylen = %d, objlen = %d, noutot = %d, nout=%d, nin=%d, nbuf=%d",
               nbytes,keylen,objlen, noutot,nout,nin,nbuf);
         uzlen = -1;
         if(alloc) delete [] *dest;
         return uzlen;
      }
      uzlen += objlen;
   } else {
      memcpy(*dest, src, keylen);
      uzlen += keylen;
      memcpy(*dest + keylen, src + keylen, objlen);
      uzlen += objlen;
   }
   return uzlen;
}

//_____________________________________________________________________________
Int_t TTreeCacheUnzip::UnzipCache()
{
   // This inflates all the buffers in the cache.. passing the data to a new
   // buffer that will only wait there to be read...
   // We can not inflate all the buffers in the cache so we will try to do
   // it by parts... there is a member calle fUnzipBufferSize which will
   // tell us the size we can allocate for this cache so we will divide
   // the prefeteched cche in chunks of this size and we will try to unzip then
   // note that we will  unzip in the order they were put into the cache not
   // the order of the transference so it has to be read in that order or the
   // pre-unzipping will be useless.
   // pos and len are used to see where we have to start unzipping...
   // and for how long..
   // returns 0 in normal conditions or -1 if error

   if(!fIsTransferred) {
      if (gDebug > 0)
         Info("UnzipCache", "It is still in the learning phase");
      return 0;
   }

   // This is the first time we unzip the cache
   if (fUnzipBufferSize == 0) {
      // creating a new buffer
      SetUnzipBufferSize((Long64_t)(fgRelBuffSize*fBufferSize));

      fMutexBuffer->Lock();   //*** fMutexBuffer Lock
      fUnzipBuffer = new char[fUnzipBufferSize];
      fMutexBuffer->UnLock(); //*** fMutexBuffer Lock
      if (gDebug > 0)
         Info("UnzipCache", "Creating a buffer of %lld bytes ", fUnzipBufferSize);
   }
   if(fNseekMax < fNseek){
      if (gDebug > 0)
         Info("UnzipCache", "Changing fNseekMax from:%d to:%d", fNseekMax, fNseek);

      fMutexList->Lock();  //*** fMutexList Lock
      Int_t *aUnzipPos = new Int_t[fNseek];
      Int_t *aUnzipLen = new Int_t[fNseek];

      for (Int_t i=0;i<fNseekMax;i++) {
         aUnzipPos[i] = fUnzipPos[i];
         aUnzipLen[i] = fUnzipLen[i];
      }

      if (fUnzipPos) delete [] fUnzipPos;
      if (fUnzipLen) delete [] fUnzipLen;

      fUnzipPos  = aUnzipPos;
      fUnzipLen  = aUnzipLen;
      fNseekMax  = fNseek;
      fMutexList->UnLock(); //*** fMutexList UnLock
   }
   fMutexList->Lock();  //*** fMutexList Lock
   Long64_t locPos = 0; // Local values for each buffer... change them together to ease sync.
   Int_t    locLen = 0;
   fNewTransfer    = kFALSE;  // abort unzipping if TFileCacheRead starts a new transfer

   // We will unzip all the buffers starting with fUnzipStart
   fUnzipStart = fUnzipEnd;

   Long64_t reqbuffer = 0;         // How much space do we need for this transfer list?
   Int_t    reqmax    = fUnzipEnd; // How many buffers?
   Int_t    unzipend  = fUnzipEnd; // starting fUnzipEnd since it will be changed later on
   for (Int_t reqi=unzipend;reqi<fNseek; reqi++) {
      // This for is inefficent since the onlz thing we want is to know how many
      // requests can fit our buffer and how big it's going to be... it migth be
      // better to just have a rough estimate but since that number is use in the first thread
      // I'm not sure about how to do it.

      const Int_t hlen=128;
      Int_t objlen=0, keylen=0;
      Int_t nbytes=0;
      GetRecordHeader(&fBuffer[fSeekPos[reqi]], hlen, nbytes, objlen, keylen);
      Int_t len = (objlen > nbytes-keylen)? keylen+objlen : nbytes;

      // We need a protection here in case a buffer is bigger than
      // the whole unzipping cache... do it only at the first iteration
      // to guarantee that it indeed doesnt fit the cache...
      if ((reqi == unzipend) && (len > fUnzipBufferSize)) {
         if (gDebug > 0)
            Info("UnzipCache", "One buffer is too big resizing from:%d to len*2:%d", fUnzipBufferSize, len*2);

         fMutexBuffer->Lock();  //*** fMutexBuffer Lock
         char *newBuffer = new char[len*2];
         memcpy(newBuffer, fUnzipBuffer, fPosWrite);
         delete [] fUnzipBuffer;

         SetUnzipBufferSize((Long64_t)(len*2));
         fUnzipBuffer = newBuffer;
         fMutexBuffer->UnLock(); //*** fMutexBuffer UnLock
      }

      // if it is going to exceed the buffer size then stop
      if( (reqbuffer + len) > fUnzipBufferSize ){
         if (gDebug > 0)
            Info("UnzipCache", "Cache found the rigth size: %lld ... breaking ", reqbuffer );
         break;
      }
      reqmax++;
      reqbuffer += len;
   }
   fUnzipNext = reqmax;  // Our new goal

   if (gDebug > 0)
      Info("UnzipCache", "Cache found the rigth size fUnzipStart:%d, fUnzipEnd:%d, fUnzipNext: %d, fNseek: %d",
           fUnzipStart, fUnzipEnd, fUnzipNext, fNseek);

   fMutexList->UnLock();  //*** fMutexList UnLock

   for (Int_t reqi = unzipend; reqi<fNseek; reqi++) {
      if (!IsActiveThread() || !fNseek || fIsLearning || fNewTransfer || !fIsTransferred) {
         if (gDebug > 0)
            Info("UnzipCache", "Sudden Break!!! IsActiveThread(): %d, fNseek: %d, fIsLearning:%d, fNewTransfer:%d",
		 IsActiveThread(), fNseek, fIsLearning, fNewTransfer);
         return 0;
      }

      // This must have this lock because UnzipBuffer can access GetRecordHeader also
      const Int_t hlen=128;
      Int_t objlen=0, keylen=0;
      Int_t nbytes=0;
      GetRecordHeader(&fBuffer[fSeekPos[reqi]], hlen, nbytes, objlen, keylen);
      Int_t len = (objlen > nbytes-keylen)? keylen+objlen : nbytes;

      // Don't do it for the first buffer since we should had done in the last cycle
      if (reqi > unzipend) {
         fMutexList->Lock();   //*** fMutexList Lock
         locPos = fUnzipPos[reqi-1] + fUnzipLen[reqi-1];
         locLen = 0; // just in case
         fMutexList->UnLock(); //*** fMutexList UnLock
      }

      // if it is going to exceed the buffer size then stop
      // this is not needed since now we calculate how many buffers fit the cache
      // keep it here just in case
      if( (locPos + len) > fUnzipBufferSize ){
         if (gDebug > 0)
            Info("UnzipCache", "Cache is full.. breaking i:%d, fUnzipBufferSize: %lld, locPos: %lld",
                 reqi, fUnzipBufferSize, locPos);
         break;
      }

      // Initially we had fBuffer with all the buffers to be unzipped... we took
      // one of then, we unzipped it and we put it in fUnzipBuffer. But the first
      // thread can start a transference at the same moment changing the content of fBuffer,
      // putting a lock on it is inneficient because we have to wait for the unzip to
      // start the transfer and I have seen that is better to just copy the data to a
      // "local variable"... but doing _new_ here wouldn't be very good also so
      // I use a preallocated buffer.
      if(fTmpBufferSz < fSeekSortLen[reqi]) {
         delete [] fTmpBuffer;
         fTmpBufferSz = fSeekSortLen[reqi]*2;
         fTmpBuffer = new char[fTmpBufferSz];
      }

      fMutexList->Lock();   // fMutexList Lock
      memcpy(fTmpBuffer, &fBuffer[fSeekPos[reqi]], fSeekSortLen[reqi]);
      fMutexList->UnLock(); // fMutexList UnLock

      char *ptr = &fUnzipBuffer[locPos];
      locLen = UnzipBuffer(&ptr, fTmpBuffer);

      R__LOCKGUARD(fMutexList); // fMutexList LOCK until going out of scope
      if (!IsActiveThread() || !fNseek || fIsLearning || fNewTransfer || !fIsTransferred)
         return 0;

      fPosWrite       = locPos + locLen;  // keep a pointer to the end of the buffer
      fUnzipPos[reqi] = locPos;
      fUnzipLen[reqi] = locLen;

      if (gDebug > 0)
         Info("UnzipCache", "reqi:%d, fSeekPos[reqi]:%d, fSeekSortLen[reqi]: %d, fUnzipPos[reqi]:%d, fUnzipLen[reqi]:%d",
	      reqi, fSeekPos[reqi], fSeekSortLen[reqi], fUnzipPos[reqi], fUnzipLen[reqi]);

      fUnzipEnd++;
      fNUnzip++;
   }
   return 0;
}

 TTreeCacheUnzip.cxx:1
 TTreeCacheUnzip.cxx:2
 TTreeCacheUnzip.cxx:3
 TTreeCacheUnzip.cxx:4
 TTreeCacheUnzip.cxx:5
 TTreeCacheUnzip.cxx:6
 TTreeCacheUnzip.cxx:7
 TTreeCacheUnzip.cxx:8
 TTreeCacheUnzip.cxx:9
 TTreeCacheUnzip.cxx:10
 TTreeCacheUnzip.cxx:11
 TTreeCacheUnzip.cxx:12
 TTreeCacheUnzip.cxx:13
 TTreeCacheUnzip.cxx:14
 TTreeCacheUnzip.cxx:15
 TTreeCacheUnzip.cxx:16
 TTreeCacheUnzip.cxx:17
 TTreeCacheUnzip.cxx:18
 TTreeCacheUnzip.cxx:19
 TTreeCacheUnzip.cxx:20
 TTreeCacheUnzip.cxx:21
 TTreeCacheUnzip.cxx:22
 TTreeCacheUnzip.cxx:23
 TTreeCacheUnzip.cxx:24
 TTreeCacheUnzip.cxx:25
 TTreeCacheUnzip.cxx:26
 TTreeCacheUnzip.cxx:27
 TTreeCacheUnzip.cxx:28
 TTreeCacheUnzip.cxx:29
 TTreeCacheUnzip.cxx:30
 TTreeCacheUnzip.cxx:31
 TTreeCacheUnzip.cxx:32
 TTreeCacheUnzip.cxx:33
 TTreeCacheUnzip.cxx:34
 TTreeCacheUnzip.cxx:35
 TTreeCacheUnzip.cxx:36
 TTreeCacheUnzip.cxx:37
 TTreeCacheUnzip.cxx:38
 TTreeCacheUnzip.cxx:39
 TTreeCacheUnzip.cxx:40
 TTreeCacheUnzip.cxx:41
 TTreeCacheUnzip.cxx:42
 TTreeCacheUnzip.cxx:43
 TTreeCacheUnzip.cxx:44
 TTreeCacheUnzip.cxx:45
 TTreeCacheUnzip.cxx:46
 TTreeCacheUnzip.cxx:47
 TTreeCacheUnzip.cxx:48
 TTreeCacheUnzip.cxx:49
 TTreeCacheUnzip.cxx:50
 TTreeCacheUnzip.cxx:51
 TTreeCacheUnzip.cxx:52
 TTreeCacheUnzip.cxx:53
 TTreeCacheUnzip.cxx:54
 TTreeCacheUnzip.cxx:55
 TTreeCacheUnzip.cxx:56
 TTreeCacheUnzip.cxx:57
 TTreeCacheUnzip.cxx:58
 TTreeCacheUnzip.cxx:59
 TTreeCacheUnzip.cxx:60
 TTreeCacheUnzip.cxx:61
 TTreeCacheUnzip.cxx:62
 TTreeCacheUnzip.cxx:63
 TTreeCacheUnzip.cxx:64
 TTreeCacheUnzip.cxx:65
 TTreeCacheUnzip.cxx:66
 TTreeCacheUnzip.cxx:67
 TTreeCacheUnzip.cxx:68
 TTreeCacheUnzip.cxx:69
 TTreeCacheUnzip.cxx:70
 TTreeCacheUnzip.cxx:71
 TTreeCacheUnzip.cxx:72
 TTreeCacheUnzip.cxx:73
 TTreeCacheUnzip.cxx:74
 TTreeCacheUnzip.cxx:75
 TTreeCacheUnzip.cxx:76
 TTreeCacheUnzip.cxx:77
 TTreeCacheUnzip.cxx:78
 TTreeCacheUnzip.cxx:79
 TTreeCacheUnzip.cxx:80
 TTreeCacheUnzip.cxx:81
 TTreeCacheUnzip.cxx:82
 TTreeCacheUnzip.cxx:83
 TTreeCacheUnzip.cxx:84
 TTreeCacheUnzip.cxx:85
 TTreeCacheUnzip.cxx:86
 TTreeCacheUnzip.cxx:87
 TTreeCacheUnzip.cxx:88
 TTreeCacheUnzip.cxx:89
 TTreeCacheUnzip.cxx:90
 TTreeCacheUnzip.cxx:91
 TTreeCacheUnzip.cxx:92
 TTreeCacheUnzip.cxx:93
 TTreeCacheUnzip.cxx:94
 TTreeCacheUnzip.cxx:95
 TTreeCacheUnzip.cxx:96
 TTreeCacheUnzip.cxx:97
 TTreeCacheUnzip.cxx:98
 TTreeCacheUnzip.cxx:99
 TTreeCacheUnzip.cxx:100
 TTreeCacheUnzip.cxx:101
 TTreeCacheUnzip.cxx:102
 TTreeCacheUnzip.cxx:103
 TTreeCacheUnzip.cxx:104
 TTreeCacheUnzip.cxx:105
 TTreeCacheUnzip.cxx:106
 TTreeCacheUnzip.cxx:107
 TTreeCacheUnzip.cxx:108
 TTreeCacheUnzip.cxx:109
 TTreeCacheUnzip.cxx:110
 TTreeCacheUnzip.cxx:111
 TTreeCacheUnzip.cxx:112
 TTreeCacheUnzip.cxx:113
 TTreeCacheUnzip.cxx:114
 TTreeCacheUnzip.cxx:115
 TTreeCacheUnzip.cxx:116
 TTreeCacheUnzip.cxx:117
 TTreeCacheUnzip.cxx:118
 TTreeCacheUnzip.cxx:119
 TTreeCacheUnzip.cxx:120
 TTreeCacheUnzip.cxx:121
 TTreeCacheUnzip.cxx:122
 TTreeCacheUnzip.cxx:123
 TTreeCacheUnzip.cxx:124
 TTreeCacheUnzip.cxx:125
 TTreeCacheUnzip.cxx:126
 TTreeCacheUnzip.cxx:127
 TTreeCacheUnzip.cxx:128
 TTreeCacheUnzip.cxx:129
 TTreeCacheUnzip.cxx:130
 TTreeCacheUnzip.cxx:131
 TTreeCacheUnzip.cxx:132
 TTreeCacheUnzip.cxx:133
 TTreeCacheUnzip.cxx:134
 TTreeCacheUnzip.cxx:135
 TTreeCacheUnzip.cxx:136
 TTreeCacheUnzip.cxx:137
 TTreeCacheUnzip.cxx:138
 TTreeCacheUnzip.cxx:139
 TTreeCacheUnzip.cxx:140
 TTreeCacheUnzip.cxx:141
 TTreeCacheUnzip.cxx:142
 TTreeCacheUnzip.cxx:143
 TTreeCacheUnzip.cxx:144
 TTreeCacheUnzip.cxx:145
 TTreeCacheUnzip.cxx:146
 TTreeCacheUnzip.cxx:147
 TTreeCacheUnzip.cxx:148
 TTreeCacheUnzip.cxx:149
 TTreeCacheUnzip.cxx:150
 TTreeCacheUnzip.cxx:151
 TTreeCacheUnzip.cxx:152
 TTreeCacheUnzip.cxx:153
 TTreeCacheUnzip.cxx:154
 TTreeCacheUnzip.cxx:155
 TTreeCacheUnzip.cxx:156
 TTreeCacheUnzip.cxx:157
 TTreeCacheUnzip.cxx:158
 TTreeCacheUnzip.cxx:159
 TTreeCacheUnzip.cxx:160
 TTreeCacheUnzip.cxx:161
 TTreeCacheUnzip.cxx:162
 TTreeCacheUnzip.cxx:163
 TTreeCacheUnzip.cxx:164
 TTreeCacheUnzip.cxx:165
 TTreeCacheUnzip.cxx:166
 TTreeCacheUnzip.cxx:167
 TTreeCacheUnzip.cxx:168
 TTreeCacheUnzip.cxx:169
 TTreeCacheUnzip.cxx:170
 TTreeCacheUnzip.cxx:171
 TTreeCacheUnzip.cxx:172
 TTreeCacheUnzip.cxx:173
 TTreeCacheUnzip.cxx:174
 TTreeCacheUnzip.cxx:175
 TTreeCacheUnzip.cxx:176
 TTreeCacheUnzip.cxx:177
 TTreeCacheUnzip.cxx:178
 TTreeCacheUnzip.cxx:179
 TTreeCacheUnzip.cxx:180
 TTreeCacheUnzip.cxx:181
 TTreeCacheUnzip.cxx:182
 TTreeCacheUnzip.cxx:183
 TTreeCacheUnzip.cxx:184
 TTreeCacheUnzip.cxx:185
 TTreeCacheUnzip.cxx:186
 TTreeCacheUnzip.cxx:187
 TTreeCacheUnzip.cxx:188
 TTreeCacheUnzip.cxx:189
 TTreeCacheUnzip.cxx:190
 TTreeCacheUnzip.cxx:191
 TTreeCacheUnzip.cxx:192
 TTreeCacheUnzip.cxx:193
 TTreeCacheUnzip.cxx:194
 TTreeCacheUnzip.cxx:195
 TTreeCacheUnzip.cxx:196
 TTreeCacheUnzip.cxx:197
 TTreeCacheUnzip.cxx:198
 TTreeCacheUnzip.cxx:199
 TTreeCacheUnzip.cxx:200
 TTreeCacheUnzip.cxx:201
 TTreeCacheUnzip.cxx:202
 TTreeCacheUnzip.cxx:203
 TTreeCacheUnzip.cxx:204
 TTreeCacheUnzip.cxx:205
 TTreeCacheUnzip.cxx:206
 TTreeCacheUnzip.cxx:207
 TTreeCacheUnzip.cxx:208
 TTreeCacheUnzip.cxx:209
 TTreeCacheUnzip.cxx:210
 TTreeCacheUnzip.cxx:211
 TTreeCacheUnzip.cxx:212
 TTreeCacheUnzip.cxx:213
 TTreeCacheUnzip.cxx:214
 TTreeCacheUnzip.cxx:215
 TTreeCacheUnzip.cxx:216
 TTreeCacheUnzip.cxx:217
 TTreeCacheUnzip.cxx:218
 TTreeCacheUnzip.cxx:219
 TTreeCacheUnzip.cxx:220
 TTreeCacheUnzip.cxx:221
 TTreeCacheUnzip.cxx:222
 TTreeCacheUnzip.cxx:223
 TTreeCacheUnzip.cxx:224
 TTreeCacheUnzip.cxx:225
 TTreeCacheUnzip.cxx:226
 TTreeCacheUnzip.cxx:227
 TTreeCacheUnzip.cxx:228
 TTreeCacheUnzip.cxx:229
 TTreeCacheUnzip.cxx:230
 TTreeCacheUnzip.cxx:231
 TTreeCacheUnzip.cxx:232
 TTreeCacheUnzip.cxx:233
 TTreeCacheUnzip.cxx:234
 TTreeCacheUnzip.cxx:235
 TTreeCacheUnzip.cxx:236
 TTreeCacheUnzip.cxx:237
 TTreeCacheUnzip.cxx:238
 TTreeCacheUnzip.cxx:239
 TTreeCacheUnzip.cxx:240
 TTreeCacheUnzip.cxx:241
 TTreeCacheUnzip.cxx:242
 TTreeCacheUnzip.cxx:243
 TTreeCacheUnzip.cxx:244
 TTreeCacheUnzip.cxx:245
 TTreeCacheUnzip.cxx:246
 TTreeCacheUnzip.cxx:247
 TTreeCacheUnzip.cxx:248
 TTreeCacheUnzip.cxx:249
 TTreeCacheUnzip.cxx:250
 TTreeCacheUnzip.cxx:251
 TTreeCacheUnzip.cxx:252
 TTreeCacheUnzip.cxx:253
 TTreeCacheUnzip.cxx:254
 TTreeCacheUnzip.cxx:255
 TTreeCacheUnzip.cxx:256
 TTreeCacheUnzip.cxx:257
 TTreeCacheUnzip.cxx:258
 TTreeCacheUnzip.cxx:259
 TTreeCacheUnzip.cxx:260
 TTreeCacheUnzip.cxx:261
 TTreeCacheUnzip.cxx:262
 TTreeCacheUnzip.cxx:263
 TTreeCacheUnzip.cxx:264
 TTreeCacheUnzip.cxx:265
 TTreeCacheUnzip.cxx:266
 TTreeCacheUnzip.cxx:267
 TTreeCacheUnzip.cxx:268
 TTreeCacheUnzip.cxx:269
 TTreeCacheUnzip.cxx:270
 TTreeCacheUnzip.cxx:271
 TTreeCacheUnzip.cxx:272
 TTreeCacheUnzip.cxx:273
 TTreeCacheUnzip.cxx:274
 TTreeCacheUnzip.cxx:275
 TTreeCacheUnzip.cxx:276
 TTreeCacheUnzip.cxx:277
 TTreeCacheUnzip.cxx:278
 TTreeCacheUnzip.cxx:279
 TTreeCacheUnzip.cxx:280
 TTreeCacheUnzip.cxx:281
 TTreeCacheUnzip.cxx:282
 TTreeCacheUnzip.cxx:283
 TTreeCacheUnzip.cxx:284
 TTreeCacheUnzip.cxx:285
 TTreeCacheUnzip.cxx:286
 TTreeCacheUnzip.cxx:287
 TTreeCacheUnzip.cxx:288
 TTreeCacheUnzip.cxx:289
 TTreeCacheUnzip.cxx:290
 TTreeCacheUnzip.cxx:291
 TTreeCacheUnzip.cxx:292
 TTreeCacheUnzip.cxx:293
 TTreeCacheUnzip.cxx:294
 TTreeCacheUnzip.cxx:295
 TTreeCacheUnzip.cxx:296
 TTreeCacheUnzip.cxx:297
 TTreeCacheUnzip.cxx:298
 TTreeCacheUnzip.cxx:299
 TTreeCacheUnzip.cxx:300
 TTreeCacheUnzip.cxx:301
 TTreeCacheUnzip.cxx:302
 TTreeCacheUnzip.cxx:303
 TTreeCacheUnzip.cxx:304
 TTreeCacheUnzip.cxx:305
 TTreeCacheUnzip.cxx:306
 TTreeCacheUnzip.cxx:307
 TTreeCacheUnzip.cxx:308
 TTreeCacheUnzip.cxx:309
 TTreeCacheUnzip.cxx:310
 TTreeCacheUnzip.cxx:311
 TTreeCacheUnzip.cxx:312
 TTreeCacheUnzip.cxx:313
 TTreeCacheUnzip.cxx:314
 TTreeCacheUnzip.cxx:315
 TTreeCacheUnzip.cxx:316
 TTreeCacheUnzip.cxx:317
 TTreeCacheUnzip.cxx:318
 TTreeCacheUnzip.cxx:319
 TTreeCacheUnzip.cxx:320
 TTreeCacheUnzip.cxx:321
 TTreeCacheUnzip.cxx:322
 TTreeCacheUnzip.cxx:323
 TTreeCacheUnzip.cxx:324
 TTreeCacheUnzip.cxx:325
 TTreeCacheUnzip.cxx:326
 TTreeCacheUnzip.cxx:327
 TTreeCacheUnzip.cxx:328
 TTreeCacheUnzip.cxx:329
 TTreeCacheUnzip.cxx:330
 TTreeCacheUnzip.cxx:331
 TTreeCacheUnzip.cxx:332
 TTreeCacheUnzip.cxx:333
 TTreeCacheUnzip.cxx:334
 TTreeCacheUnzip.cxx:335
 TTreeCacheUnzip.cxx:336
 TTreeCacheUnzip.cxx:337
 TTreeCacheUnzip.cxx:338
 TTreeCacheUnzip.cxx:339
 TTreeCacheUnzip.cxx:340
 TTreeCacheUnzip.cxx:341
 TTreeCacheUnzip.cxx:342
 TTreeCacheUnzip.cxx:343
 TTreeCacheUnzip.cxx:344
 TTreeCacheUnzip.cxx:345
 TTreeCacheUnzip.cxx:346
 TTreeCacheUnzip.cxx:347
 TTreeCacheUnzip.cxx:348
 TTreeCacheUnzip.cxx:349
 TTreeCacheUnzip.cxx:350
 TTreeCacheUnzip.cxx:351
 TTreeCacheUnzip.cxx:352
 TTreeCacheUnzip.cxx:353
 TTreeCacheUnzip.cxx:354
 TTreeCacheUnzip.cxx:355
 TTreeCacheUnzip.cxx:356
 TTreeCacheUnzip.cxx:357
 TTreeCacheUnzip.cxx:358
 TTreeCacheUnzip.cxx:359
 TTreeCacheUnzip.cxx:360
 TTreeCacheUnzip.cxx:361
 TTreeCacheUnzip.cxx:362
 TTreeCacheUnzip.cxx:363
 TTreeCacheUnzip.cxx:364
 TTreeCacheUnzip.cxx:365
 TTreeCacheUnzip.cxx:366
 TTreeCacheUnzip.cxx:367
 TTreeCacheUnzip.cxx:368
 TTreeCacheUnzip.cxx:369
 TTreeCacheUnzip.cxx:370
 TTreeCacheUnzip.cxx:371
 TTreeCacheUnzip.cxx:372
 TTreeCacheUnzip.cxx:373
 TTreeCacheUnzip.cxx:374
 TTreeCacheUnzip.cxx:375
 TTreeCacheUnzip.cxx:376
 TTreeCacheUnzip.cxx:377
 TTreeCacheUnzip.cxx:378
 TTreeCacheUnzip.cxx:379
 TTreeCacheUnzip.cxx:380
 TTreeCacheUnzip.cxx:381
 TTreeCacheUnzip.cxx:382
 TTreeCacheUnzip.cxx:383
 TTreeCacheUnzip.cxx:384
 TTreeCacheUnzip.cxx:385
 TTreeCacheUnzip.cxx:386
 TTreeCacheUnzip.cxx:387
 TTreeCacheUnzip.cxx:388
 TTreeCacheUnzip.cxx:389
 TTreeCacheUnzip.cxx:390
 TTreeCacheUnzip.cxx:391
 TTreeCacheUnzip.cxx:392
 TTreeCacheUnzip.cxx:393
 TTreeCacheUnzip.cxx:394
 TTreeCacheUnzip.cxx:395
 TTreeCacheUnzip.cxx:396
 TTreeCacheUnzip.cxx:397
 TTreeCacheUnzip.cxx:398
 TTreeCacheUnzip.cxx:399
 TTreeCacheUnzip.cxx:400
 TTreeCacheUnzip.cxx:401
 TTreeCacheUnzip.cxx:402
 TTreeCacheUnzip.cxx:403
 TTreeCacheUnzip.cxx:404
 TTreeCacheUnzip.cxx:405
 TTreeCacheUnzip.cxx:406
 TTreeCacheUnzip.cxx:407
 TTreeCacheUnzip.cxx:408
 TTreeCacheUnzip.cxx:409
 TTreeCacheUnzip.cxx:410
 TTreeCacheUnzip.cxx:411
 TTreeCacheUnzip.cxx:412
 TTreeCacheUnzip.cxx:413
 TTreeCacheUnzip.cxx:414
 TTreeCacheUnzip.cxx:415
 TTreeCacheUnzip.cxx:416
 TTreeCacheUnzip.cxx:417
 TTreeCacheUnzip.cxx:418
 TTreeCacheUnzip.cxx:419
 TTreeCacheUnzip.cxx:420
 TTreeCacheUnzip.cxx:421
 TTreeCacheUnzip.cxx:422
 TTreeCacheUnzip.cxx:423
 TTreeCacheUnzip.cxx:424
 TTreeCacheUnzip.cxx:425
 TTreeCacheUnzip.cxx:426
 TTreeCacheUnzip.cxx:427
 TTreeCacheUnzip.cxx:428
 TTreeCacheUnzip.cxx:429
 TTreeCacheUnzip.cxx:430
 TTreeCacheUnzip.cxx:431
 TTreeCacheUnzip.cxx:432
 TTreeCacheUnzip.cxx:433
 TTreeCacheUnzip.cxx:434
 TTreeCacheUnzip.cxx:435
 TTreeCacheUnzip.cxx:436
 TTreeCacheUnzip.cxx:437
 TTreeCacheUnzip.cxx:438
 TTreeCacheUnzip.cxx:439
 TTreeCacheUnzip.cxx:440
 TTreeCacheUnzip.cxx:441
 TTreeCacheUnzip.cxx:442
 TTreeCacheUnzip.cxx:443
 TTreeCacheUnzip.cxx:444
 TTreeCacheUnzip.cxx:445
 TTreeCacheUnzip.cxx:446
 TTreeCacheUnzip.cxx:447
 TTreeCacheUnzip.cxx:448
 TTreeCacheUnzip.cxx:449
 TTreeCacheUnzip.cxx:450
 TTreeCacheUnzip.cxx:451
 TTreeCacheUnzip.cxx:452
 TTreeCacheUnzip.cxx:453
 TTreeCacheUnzip.cxx:454
 TTreeCacheUnzip.cxx:455
 TTreeCacheUnzip.cxx:456
 TTreeCacheUnzip.cxx:457
 TTreeCacheUnzip.cxx:458
 TTreeCacheUnzip.cxx:459
 TTreeCacheUnzip.cxx:460
 TTreeCacheUnzip.cxx:461
 TTreeCacheUnzip.cxx:462
 TTreeCacheUnzip.cxx:463
 TTreeCacheUnzip.cxx:464
 TTreeCacheUnzip.cxx:465
 TTreeCacheUnzip.cxx:466
 TTreeCacheUnzip.cxx:467
 TTreeCacheUnzip.cxx:468
 TTreeCacheUnzip.cxx:469
 TTreeCacheUnzip.cxx:470
 TTreeCacheUnzip.cxx:471
 TTreeCacheUnzip.cxx:472
 TTreeCacheUnzip.cxx:473
 TTreeCacheUnzip.cxx:474
 TTreeCacheUnzip.cxx:475
 TTreeCacheUnzip.cxx:476
 TTreeCacheUnzip.cxx:477
 TTreeCacheUnzip.cxx:478
 TTreeCacheUnzip.cxx:479
 TTreeCacheUnzip.cxx:480
 TTreeCacheUnzip.cxx:481
 TTreeCacheUnzip.cxx:482
 TTreeCacheUnzip.cxx:483
 TTreeCacheUnzip.cxx:484
 TTreeCacheUnzip.cxx:485
 TTreeCacheUnzip.cxx:486
 TTreeCacheUnzip.cxx:487
 TTreeCacheUnzip.cxx:488
 TTreeCacheUnzip.cxx:489
 TTreeCacheUnzip.cxx:490
 TTreeCacheUnzip.cxx:491
 TTreeCacheUnzip.cxx:492
 TTreeCacheUnzip.cxx:493
 TTreeCacheUnzip.cxx:494
 TTreeCacheUnzip.cxx:495
 TTreeCacheUnzip.cxx:496
 TTreeCacheUnzip.cxx:497
 TTreeCacheUnzip.cxx:498
 TTreeCacheUnzip.cxx:499
 TTreeCacheUnzip.cxx:500
 TTreeCacheUnzip.cxx:501
 TTreeCacheUnzip.cxx:502
 TTreeCacheUnzip.cxx:503
 TTreeCacheUnzip.cxx:504
 TTreeCacheUnzip.cxx:505
 TTreeCacheUnzip.cxx:506
 TTreeCacheUnzip.cxx:507
 TTreeCacheUnzip.cxx:508
 TTreeCacheUnzip.cxx:509
 TTreeCacheUnzip.cxx:510
 TTreeCacheUnzip.cxx:511
 TTreeCacheUnzip.cxx:512
 TTreeCacheUnzip.cxx:513
 TTreeCacheUnzip.cxx:514
 TTreeCacheUnzip.cxx:515
 TTreeCacheUnzip.cxx:516
 TTreeCacheUnzip.cxx:517
 TTreeCacheUnzip.cxx:518
 TTreeCacheUnzip.cxx:519
 TTreeCacheUnzip.cxx:520
 TTreeCacheUnzip.cxx:521
 TTreeCacheUnzip.cxx:522
 TTreeCacheUnzip.cxx:523
 TTreeCacheUnzip.cxx:524
 TTreeCacheUnzip.cxx:525
 TTreeCacheUnzip.cxx:526
 TTreeCacheUnzip.cxx:527
 TTreeCacheUnzip.cxx:528
 TTreeCacheUnzip.cxx:529
 TTreeCacheUnzip.cxx:530
 TTreeCacheUnzip.cxx:531
 TTreeCacheUnzip.cxx:532
 TTreeCacheUnzip.cxx:533
 TTreeCacheUnzip.cxx:534
 TTreeCacheUnzip.cxx:535
 TTreeCacheUnzip.cxx:536
 TTreeCacheUnzip.cxx:537
 TTreeCacheUnzip.cxx:538
 TTreeCacheUnzip.cxx:539
 TTreeCacheUnzip.cxx:540
 TTreeCacheUnzip.cxx:541
 TTreeCacheUnzip.cxx:542
 TTreeCacheUnzip.cxx:543
 TTreeCacheUnzip.cxx:544
 TTreeCacheUnzip.cxx:545
 TTreeCacheUnzip.cxx:546
 TTreeCacheUnzip.cxx:547
 TTreeCacheUnzip.cxx:548
 TTreeCacheUnzip.cxx:549
 TTreeCacheUnzip.cxx:550
 TTreeCacheUnzip.cxx:551
 TTreeCacheUnzip.cxx:552
 TTreeCacheUnzip.cxx:553
 TTreeCacheUnzip.cxx:554
 TTreeCacheUnzip.cxx:555
 TTreeCacheUnzip.cxx:556
 TTreeCacheUnzip.cxx:557
 TTreeCacheUnzip.cxx:558
 TTreeCacheUnzip.cxx:559
 TTreeCacheUnzip.cxx:560
 TTreeCacheUnzip.cxx:561
 TTreeCacheUnzip.cxx:562
 TTreeCacheUnzip.cxx:563
 TTreeCacheUnzip.cxx:564
 TTreeCacheUnzip.cxx:565
 TTreeCacheUnzip.cxx:566
 TTreeCacheUnzip.cxx:567
 TTreeCacheUnzip.cxx:568
 TTreeCacheUnzip.cxx:569
 TTreeCacheUnzip.cxx:570
 TTreeCacheUnzip.cxx:571
 TTreeCacheUnzip.cxx:572
 TTreeCacheUnzip.cxx:573
 TTreeCacheUnzip.cxx:574
 TTreeCacheUnzip.cxx:575
 TTreeCacheUnzip.cxx:576
 TTreeCacheUnzip.cxx:577
 TTreeCacheUnzip.cxx:578
 TTreeCacheUnzip.cxx:579
 TTreeCacheUnzip.cxx:580
 TTreeCacheUnzip.cxx:581
 TTreeCacheUnzip.cxx:582
 TTreeCacheUnzip.cxx:583
 TTreeCacheUnzip.cxx:584
 TTreeCacheUnzip.cxx:585
 TTreeCacheUnzip.cxx:586
 TTreeCacheUnzip.cxx:587
 TTreeCacheUnzip.cxx:588
 TTreeCacheUnzip.cxx:589
 TTreeCacheUnzip.cxx:590
 TTreeCacheUnzip.cxx:591
 TTreeCacheUnzip.cxx:592
 TTreeCacheUnzip.cxx:593
 TTreeCacheUnzip.cxx:594
 TTreeCacheUnzip.cxx:595
 TTreeCacheUnzip.cxx:596
 TTreeCacheUnzip.cxx:597
 TTreeCacheUnzip.cxx:598
 TTreeCacheUnzip.cxx:599
 TTreeCacheUnzip.cxx:600
 TTreeCacheUnzip.cxx:601
 TTreeCacheUnzip.cxx:602
 TTreeCacheUnzip.cxx:603
 TTreeCacheUnzip.cxx:604
 TTreeCacheUnzip.cxx:605
 TTreeCacheUnzip.cxx:606
 TTreeCacheUnzip.cxx:607
 TTreeCacheUnzip.cxx:608
 TTreeCacheUnzip.cxx:609
 TTreeCacheUnzip.cxx:610
 TTreeCacheUnzip.cxx:611
 TTreeCacheUnzip.cxx:612
 TTreeCacheUnzip.cxx:613
 TTreeCacheUnzip.cxx:614
 TTreeCacheUnzip.cxx:615
 TTreeCacheUnzip.cxx:616
 TTreeCacheUnzip.cxx:617
 TTreeCacheUnzip.cxx:618
 TTreeCacheUnzip.cxx:619
 TTreeCacheUnzip.cxx:620
 TTreeCacheUnzip.cxx:621
 TTreeCacheUnzip.cxx:622
 TTreeCacheUnzip.cxx:623
 TTreeCacheUnzip.cxx:624
 TTreeCacheUnzip.cxx:625
 TTreeCacheUnzip.cxx:626
 TTreeCacheUnzip.cxx:627
 TTreeCacheUnzip.cxx:628
 TTreeCacheUnzip.cxx:629
 TTreeCacheUnzip.cxx:630
 TTreeCacheUnzip.cxx:631
 TTreeCacheUnzip.cxx:632
 TTreeCacheUnzip.cxx:633
 TTreeCacheUnzip.cxx:634
 TTreeCacheUnzip.cxx:635
 TTreeCacheUnzip.cxx:636
 TTreeCacheUnzip.cxx:637
 TTreeCacheUnzip.cxx:638
 TTreeCacheUnzip.cxx:639
 TTreeCacheUnzip.cxx:640
 TTreeCacheUnzip.cxx:641
 TTreeCacheUnzip.cxx:642
 TTreeCacheUnzip.cxx:643
 TTreeCacheUnzip.cxx:644
 TTreeCacheUnzip.cxx:645
 TTreeCacheUnzip.cxx:646
 TTreeCacheUnzip.cxx:647
 TTreeCacheUnzip.cxx:648
 TTreeCacheUnzip.cxx:649
 TTreeCacheUnzip.cxx:650
 TTreeCacheUnzip.cxx:651
 TTreeCacheUnzip.cxx:652
 TTreeCacheUnzip.cxx:653
 TTreeCacheUnzip.cxx:654
 TTreeCacheUnzip.cxx:655
 TTreeCacheUnzip.cxx:656
 TTreeCacheUnzip.cxx:657
 TTreeCacheUnzip.cxx:658
 TTreeCacheUnzip.cxx:659
 TTreeCacheUnzip.cxx:660
 TTreeCacheUnzip.cxx:661
 TTreeCacheUnzip.cxx:662
 TTreeCacheUnzip.cxx:663
 TTreeCacheUnzip.cxx:664
 TTreeCacheUnzip.cxx:665
 TTreeCacheUnzip.cxx:666
 TTreeCacheUnzip.cxx:667
 TTreeCacheUnzip.cxx:668
 TTreeCacheUnzip.cxx:669
 TTreeCacheUnzip.cxx:670
 TTreeCacheUnzip.cxx:671
 TTreeCacheUnzip.cxx:672
 TTreeCacheUnzip.cxx:673
 TTreeCacheUnzip.cxx:674
 TTreeCacheUnzip.cxx:675
 TTreeCacheUnzip.cxx:676
 TTreeCacheUnzip.cxx:677
 TTreeCacheUnzip.cxx:678
 TTreeCacheUnzip.cxx:679
 TTreeCacheUnzip.cxx:680
 TTreeCacheUnzip.cxx:681
 TTreeCacheUnzip.cxx:682
 TTreeCacheUnzip.cxx:683
 TTreeCacheUnzip.cxx:684
 TTreeCacheUnzip.cxx:685
 TTreeCacheUnzip.cxx:686
 TTreeCacheUnzip.cxx:687
 TTreeCacheUnzip.cxx:688
 TTreeCacheUnzip.cxx:689
 TTreeCacheUnzip.cxx:690
 TTreeCacheUnzip.cxx:691
 TTreeCacheUnzip.cxx:692
 TTreeCacheUnzip.cxx:693
 TTreeCacheUnzip.cxx:694
 TTreeCacheUnzip.cxx:695
 TTreeCacheUnzip.cxx:696
 TTreeCacheUnzip.cxx:697
 TTreeCacheUnzip.cxx:698
 TTreeCacheUnzip.cxx:699
 TTreeCacheUnzip.cxx:700
 TTreeCacheUnzip.cxx:701
 TTreeCacheUnzip.cxx:702
 TTreeCacheUnzip.cxx:703
 TTreeCacheUnzip.cxx:704
 TTreeCacheUnzip.cxx:705
 TTreeCacheUnzip.cxx:706
 TTreeCacheUnzip.cxx:707
 TTreeCacheUnzip.cxx:708
 TTreeCacheUnzip.cxx:709
 TTreeCacheUnzip.cxx:710
 TTreeCacheUnzip.cxx:711
 TTreeCacheUnzip.cxx:712
 TTreeCacheUnzip.cxx:713
 TTreeCacheUnzip.cxx:714
 TTreeCacheUnzip.cxx:715
 TTreeCacheUnzip.cxx:716
 TTreeCacheUnzip.cxx:717
 TTreeCacheUnzip.cxx:718
 TTreeCacheUnzip.cxx:719
 TTreeCacheUnzip.cxx:720
 TTreeCacheUnzip.cxx:721
 TTreeCacheUnzip.cxx:722
 TTreeCacheUnzip.cxx:723
 TTreeCacheUnzip.cxx:724
 TTreeCacheUnzip.cxx:725
 TTreeCacheUnzip.cxx:726
 TTreeCacheUnzip.cxx:727
 TTreeCacheUnzip.cxx:728
 TTreeCacheUnzip.cxx:729
 TTreeCacheUnzip.cxx:730
 TTreeCacheUnzip.cxx:731
 TTreeCacheUnzip.cxx:732
 TTreeCacheUnzip.cxx:733
 TTreeCacheUnzip.cxx:734
 TTreeCacheUnzip.cxx:735
 TTreeCacheUnzip.cxx:736
 TTreeCacheUnzip.cxx:737
 TTreeCacheUnzip.cxx:738
 TTreeCacheUnzip.cxx:739
 TTreeCacheUnzip.cxx:740
 TTreeCacheUnzip.cxx:741
 TTreeCacheUnzip.cxx:742
 TTreeCacheUnzip.cxx:743
 TTreeCacheUnzip.cxx:744
 TTreeCacheUnzip.cxx:745
 TTreeCacheUnzip.cxx:746
 TTreeCacheUnzip.cxx:747
 TTreeCacheUnzip.cxx:748
 TTreeCacheUnzip.cxx:749
 TTreeCacheUnzip.cxx:750
 TTreeCacheUnzip.cxx:751
 TTreeCacheUnzip.cxx:752
 TTreeCacheUnzip.cxx:753
 TTreeCacheUnzip.cxx:754
 TTreeCacheUnzip.cxx:755
 TTreeCacheUnzip.cxx:756
 TTreeCacheUnzip.cxx:757
 TTreeCacheUnzip.cxx:758
 TTreeCacheUnzip.cxx:759
 TTreeCacheUnzip.cxx:760
 TTreeCacheUnzip.cxx:761
 TTreeCacheUnzip.cxx:762
 TTreeCacheUnzip.cxx:763
 TTreeCacheUnzip.cxx:764
 TTreeCacheUnzip.cxx:765
 TTreeCacheUnzip.cxx:766
 TTreeCacheUnzip.cxx:767
 TTreeCacheUnzip.cxx:768
 TTreeCacheUnzip.cxx:769
 TTreeCacheUnzip.cxx:770
 TTreeCacheUnzip.cxx:771
 TTreeCacheUnzip.cxx:772
 TTreeCacheUnzip.cxx:773
 TTreeCacheUnzip.cxx:774
 TTreeCacheUnzip.cxx:775
 TTreeCacheUnzip.cxx:776
 TTreeCacheUnzip.cxx:777
 TTreeCacheUnzip.cxx:778
 TTreeCacheUnzip.cxx:779
 TTreeCacheUnzip.cxx:780
 TTreeCacheUnzip.cxx:781
 TTreeCacheUnzip.cxx:782
 TTreeCacheUnzip.cxx:783
 TTreeCacheUnzip.cxx:784
 TTreeCacheUnzip.cxx:785
 TTreeCacheUnzip.cxx:786
 TTreeCacheUnzip.cxx:787
 TTreeCacheUnzip.cxx:788
 TTreeCacheUnzip.cxx:789
 TTreeCacheUnzip.cxx:790
 TTreeCacheUnzip.cxx:791
 TTreeCacheUnzip.cxx:792
 TTreeCacheUnzip.cxx:793
 TTreeCacheUnzip.cxx:794
 TTreeCacheUnzip.cxx:795
 TTreeCacheUnzip.cxx:796
 TTreeCacheUnzip.cxx:797
 TTreeCacheUnzip.cxx:798
 TTreeCacheUnzip.cxx:799
 TTreeCacheUnzip.cxx:800
 TTreeCacheUnzip.cxx:801
 TTreeCacheUnzip.cxx:802
 TTreeCacheUnzip.cxx:803
 TTreeCacheUnzip.cxx:804
 TTreeCacheUnzip.cxx:805
 TTreeCacheUnzip.cxx:806
 TTreeCacheUnzip.cxx:807
 TTreeCacheUnzip.cxx:808
 TTreeCacheUnzip.cxx:809
 TTreeCacheUnzip.cxx:810
 TTreeCacheUnzip.cxx:811
 TTreeCacheUnzip.cxx:812
 TTreeCacheUnzip.cxx:813
 TTreeCacheUnzip.cxx:814
 TTreeCacheUnzip.cxx:815
 TTreeCacheUnzip.cxx:816
 TTreeCacheUnzip.cxx:817
 TTreeCacheUnzip.cxx:818
 TTreeCacheUnzip.cxx:819
 TTreeCacheUnzip.cxx:820
 TTreeCacheUnzip.cxx:821
 TTreeCacheUnzip.cxx:822
 TTreeCacheUnzip.cxx:823
 TTreeCacheUnzip.cxx:824
 TTreeCacheUnzip.cxx:825
 TTreeCacheUnzip.cxx:826
 TTreeCacheUnzip.cxx:827
 TTreeCacheUnzip.cxx:828
 TTreeCacheUnzip.cxx:829
 TTreeCacheUnzip.cxx:830
 TTreeCacheUnzip.cxx:831
 TTreeCacheUnzip.cxx:832
 TTreeCacheUnzip.cxx:833
 TTreeCacheUnzip.cxx:834
 TTreeCacheUnzip.cxx:835
 TTreeCacheUnzip.cxx:836
 TTreeCacheUnzip.cxx:837
 TTreeCacheUnzip.cxx:838
 TTreeCacheUnzip.cxx:839
 TTreeCacheUnzip.cxx:840
 TTreeCacheUnzip.cxx:841
 TTreeCacheUnzip.cxx:842
 TTreeCacheUnzip.cxx:843
 TTreeCacheUnzip.cxx:844
 TTreeCacheUnzip.cxx:845
 TTreeCacheUnzip.cxx:846
 TTreeCacheUnzip.cxx:847
 TTreeCacheUnzip.cxx:848
 TTreeCacheUnzip.cxx:849
 TTreeCacheUnzip.cxx:850
 TTreeCacheUnzip.cxx:851
 TTreeCacheUnzip.cxx:852
 TTreeCacheUnzip.cxx:853
 TTreeCacheUnzip.cxx:854
 TTreeCacheUnzip.cxx:855
 TTreeCacheUnzip.cxx:856
 TTreeCacheUnzip.cxx:857
 TTreeCacheUnzip.cxx:858
 TTreeCacheUnzip.cxx:859
 TTreeCacheUnzip.cxx:860
 TTreeCacheUnzip.cxx:861
 TTreeCacheUnzip.cxx:862
 TTreeCacheUnzip.cxx:863
 TTreeCacheUnzip.cxx:864
 TTreeCacheUnzip.cxx:865
 TTreeCacheUnzip.cxx:866
 TTreeCacheUnzip.cxx:867
 TTreeCacheUnzip.cxx:868
 TTreeCacheUnzip.cxx:869
 TTreeCacheUnzip.cxx:870
 TTreeCacheUnzip.cxx:871
 TTreeCacheUnzip.cxx:872
 TTreeCacheUnzip.cxx:873
 TTreeCacheUnzip.cxx:874
 TTreeCacheUnzip.cxx:875
 TTreeCacheUnzip.cxx:876
 TTreeCacheUnzip.cxx:877
 TTreeCacheUnzip.cxx:878
 TTreeCacheUnzip.cxx:879
 TTreeCacheUnzip.cxx:880
 TTreeCacheUnzip.cxx:881
 TTreeCacheUnzip.cxx:882
 TTreeCacheUnzip.cxx:883
 TTreeCacheUnzip.cxx:884
 TTreeCacheUnzip.cxx:885
 TTreeCacheUnzip.cxx:886
 TTreeCacheUnzip.cxx:887
 TTreeCacheUnzip.cxx:888
 TTreeCacheUnzip.cxx:889
 TTreeCacheUnzip.cxx:890
 TTreeCacheUnzip.cxx:891
 TTreeCacheUnzip.cxx:892
 TTreeCacheUnzip.cxx:893
 TTreeCacheUnzip.cxx:894
 TTreeCacheUnzip.cxx:895
 TTreeCacheUnzip.cxx:896
 TTreeCacheUnzip.cxx:897
 TTreeCacheUnzip.cxx:898
 TTreeCacheUnzip.cxx:899
 TTreeCacheUnzip.cxx:900
 TTreeCacheUnzip.cxx:901
 TTreeCacheUnzip.cxx:902
 TTreeCacheUnzip.cxx:903
 TTreeCacheUnzip.cxx:904
 TTreeCacheUnzip.cxx:905
 TTreeCacheUnzip.cxx:906
 TTreeCacheUnzip.cxx:907
 TTreeCacheUnzip.cxx:908
 TTreeCacheUnzip.cxx:909
 TTreeCacheUnzip.cxx:910
 TTreeCacheUnzip.cxx:911
 TTreeCacheUnzip.cxx:912
 TTreeCacheUnzip.cxx:913
 TTreeCacheUnzip.cxx:914
 TTreeCacheUnzip.cxx:915
 TTreeCacheUnzip.cxx:916
 TTreeCacheUnzip.cxx:917
 TTreeCacheUnzip.cxx:918
 TTreeCacheUnzip.cxx:919
 TTreeCacheUnzip.cxx:920
 TTreeCacheUnzip.cxx:921
 TTreeCacheUnzip.cxx:922
 TTreeCacheUnzip.cxx:923
 TTreeCacheUnzip.cxx:924
 TTreeCacheUnzip.cxx:925
 TTreeCacheUnzip.cxx:926
 TTreeCacheUnzip.cxx:927
 TTreeCacheUnzip.cxx:928
 TTreeCacheUnzip.cxx:929
 TTreeCacheUnzip.cxx:930
 TTreeCacheUnzip.cxx:931
 TTreeCacheUnzip.cxx:932
 TTreeCacheUnzip.cxx:933
 TTreeCacheUnzip.cxx:934
 TTreeCacheUnzip.cxx:935
 TTreeCacheUnzip.cxx:936
 TTreeCacheUnzip.cxx:937
 TTreeCacheUnzip.cxx:938
 TTreeCacheUnzip.cxx:939
 TTreeCacheUnzip.cxx:940
 TTreeCacheUnzip.cxx:941
 TTreeCacheUnzip.cxx:942
 TTreeCacheUnzip.cxx:943
 TTreeCacheUnzip.cxx:944
 TTreeCacheUnzip.cxx:945
 TTreeCacheUnzip.cxx:946
 TTreeCacheUnzip.cxx:947
 TTreeCacheUnzip.cxx:948
 TTreeCacheUnzip.cxx:949
 TTreeCacheUnzip.cxx:950