// @(#)root/io:$Id: 3a19890259ad6443ee313e090166614971ad4296 $
// Author: Rene Brun   28/11/94

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

////////////////////////////////////////////////////////////////////////////////
// A ROOT file is a suite of consecutive data records (TKey's) with
// the following format (see also the TKey class). If the key is
// located past the 32 bit file limit (> 2 GB) then some fields will
// be 8 instead of 4 bytes:
//    1->4            Nbytes    = Length of compressed object (in bytes)
//    5->6            Version   = TKey version identifier
//    7->10           ObjLen    = Length of uncompressed object
//    11->14          Datime    = Date and time when object was written to file
//    15->16          KeyLen    = Length of the key structure (in bytes)
//    17->18          Cycle     = Cycle of key
//    19->22 [19->26] SeekKey   = Pointer to record itself (consistency check)
//    23->26 [27->34] SeekPdir  = Pointer to directory header
//    27->27 [35->35] lname     = Number of bytes in the class name
//    28->.. [36->..] ClassName = Object Class Name
//    ..->..          lname     = Number of bytes in the object name
//    ..->..          Name      = lName bytes with the name of the object
//    ..->..          lTitle    = Number of bytes in the object title
//    ..->..          Title     = Title of the object
//    ----->          DATA      = Data bytes associated to the object
//
// The first data record starts at byte fBEGIN (currently set to kBEGIN).
// Bytes 1->kBEGIN contain the file description, when fVersion >= 1000000
// it is a large file (> 2 GB) and the offsets will be 8 bytes long and
// fUnits will be set to 8:
//    1->4            "root"      = Root file identifier
//    5->8            fVersion    = File format version
//    9->12           fBEGIN      = Pointer to first data record
//    13->16 [13->20] fEND        = Pointer to first free word at the EOF
//    17->20 [21->28] fSeekFree   = Pointer to FREE data record
//    21->24 [29->32] fNbytesFree = Number of bytes in FREE data record
//    25->28 [33->36] nfree       = Number of free data records
//    29->32 [37->40] fNbytesName = Number of bytes in TNamed at creation time
//    33->33 [41->41] fUnits      = Number of bytes for file pointers
//    34->37 [42->45] fCompress   = Compression level and algorithm
//    38->41 [46->53] fSeekInfo   = Pointer to TStreamerInfo record
//    42->45 [54->57] fNbytesInfo = Number of bytes in TStreamerInfo record
//    46->63 [58->75] fUUID       = Universal Unique ID
//Begin_Html
/*
<img src="gif/file_layout.gif">
*/
//End_Html
//
// The structure of a directory is shown in TDirectoryFile::TDirectoryFile
//
////////////////////////////////////////////////////////////////////////////////

#include "RConfig.h"

#ifdef R__LINUX
// for posix_fadvise
#ifndef _XOPEN_SOURCE
#define _XOPEN_SOURCE 600
#endif
#endif
#include <fcntl.h>
#include <errno.h>
#include <sys/stat.h>
#ifndef WIN32
#   include <unistd.h>
#else
#   define ssize_t int
#   include <io.h>
#   include <sys/types.h>
#endif

#include "Bytes.h"
#include "Compression.h"
#include "Riostream.h"
#include "RConfigure.h"
#include "Strlen.h"
#include "TArrayC.h"
#include "TClass.h"
#include "TClassEdit.h"
#include "TClassTable.h"
#include "TDatime.h"
#include "TError.h"
#include "TFile.h"
#include "TFileCacheRead.h"
#include "TFileCacheWrite.h"
#include "TFree.h"
#include "TInterpreter.h"
#include "TKey.h"
#include "TMakeProject.h"
#include "TPluginManager.h"
#include "TProcessUUID.h"
#include "TRegexp.h"
#include "TPRegexp.h"
#include "TROOT.h"
#include "TStreamerInfo.h"
#include "TStreamerElement.h"
#include "TSystem.h"
#include "TTimeStamp.h"
#include "TVirtualPerfStats.h"
#include "TArchiveFile.h"
#include "TEnv.h"
#include "TVirtualMonitoring.h"
#include "TVirtualMutex.h"
#include "TMathBase.h"
#include "TObjString.h"
#include "TStopwatch.h"
#include "compiledata.h"
#include <cmath>
#include <set>
#include "TSchemaRule.h"
#include "TSchemaRuleSet.h"
#include "TThreadSlots.h"
#include "TGlobal.h"

using std::sqrt;

std::atomic<Long64_t> TFile::fgBytesRead{0};
std::atomic<Long64_t> TFile::fgBytesWrite{0};
std::atomic<Long64_t> TFile::fgFileCounter{0};
std::atomic<Int_t>    TFile::fgReadCalls{0};
Int_t    TFile::fgReadaheadSize = 256000;
Bool_t   TFile::fgReadInfo = kTRUE;
TList   *TFile::fgAsyncOpenRequests = 0;
TString  TFile::fgCacheFileDir;
Bool_t   TFile::fgCacheFileForce = kFALSE;
Bool_t   TFile::fgCacheFileDisconnected = kTRUE;
UInt_t   TFile::fgOpenTimeout = TFile::kEternalTimeout;
Bool_t   TFile::fgOnlyStaged = 0;

const Int_t kBEGIN = 100;

ClassImp(TFile)

//*-*x17 macros/layout_file
// Needed to add the "fake" global gFile to the list of globals.
namespace {
static struct AddPseudoGlobals {
AddPseudoGlobals() {
   // User "gCling" as synonym for "libCore static initialization has happened".
   // This code here must not trigger it.
   TGlobalMappedFunction::Add(new TGlobalMappedFunction("gFile", "TFile*",
                                 (TGlobalMappedFunction::GlobalFunc_t)&TFile::CurrentFile));
}
} gAddPseudoGlobals;
}
//______________________________________________________________________________
TFile::TFile() : TDirectoryFile(), fInfoCache(0)
{
   // File default Constructor.

   fD               = -1;
   fFree            = 0;
   fWritten         = 0;
   fSumBuffer       = 0;
   fSum2Buffer      = 0;
   fClassIndex      = 0;
   fCompress        = 0;
   fProcessIDs      = 0;
   fNProcessIDs     = 0;
   fOffset          = 0;
   fArchive         = 0;
   fCacheRead       = 0;
   fCacheReadMap    = new TMap();
   fCacheWrite      = 0;
   fArchiveOffset   = 0;
   fReadCalls       = 0;
   fInfoCache       = 0;
   fOpenPhases      = 0;
   fNoAnchorInName  = kFALSE;
   fIsRootFile      = kTRUE;
   fIsArchive       = kFALSE;
   fInitDone        = kFALSE;
   fMustFlush       = kTRUE;
   fIsPcmFile       = kFALSE;
   fAsyncHandle     = 0;
   fAsyncOpenStatus = kAOSNotAsync;
   SetBit(kBinaryFile, kTRUE);

   fBEGIN          = 0;
   fEND            = 0;
   fBytesRead      = 0;
   fBytesReadExtra = 0;
   fBytesWrite     = 0;
   fCompress       = 0;
   fNbytesFree     = 0;
   fNbytesInfo     = 0;
   fSeekFree       = 0;
   fSeekInfo       = 0;
   fUnits          = 0;
   fVersion        = 0;

   if (gDebug)
      Info("TFile", "default ctor");
}

//_____________________________________________________________________________
TFile::TFile(const char *fname1, Option_t *option, const char *ftitle, Int_t compress)
           : TDirectoryFile(), fUrl(fname1,kTRUE), fInfoCache(0), fOpenPhases(0)
{
   // Opens or creates a local ROOT file whose name is fname1. It is
   // recommended to specify fname1 as "<file>.root". The suffix ".root"
   // will be used by object browsers to automatically identify the file as
   // a ROOT file. If the constructor fails in any way IsZombie() will
   // return true. Use IsOpen() to check if the file is (still) open.
   //
   // To open non-local files use the static TFile::Open() method, that
   // will take care of opening the files using the correct remote file
   // access plugin.
   //
   // If option = NEW or CREATE   create a new file and open it for writing,
   //                             if the file already exists the file is
   //                             not opened.
   //           = RECREATE        create a new file, if the file already
   //                             exists it will be overwritten.
   //           = UPDATE          open an existing file for writing.
   //                             if no file exists, it is created.
   //           = READ            open an existing file for reading (default).
   //           = NET             used by derived remote file access
   //                             classes, not a user callable option
   //           = WEB             used by derived remote http access
   //                             class, not a user callable option
   // If option = "" (default), READ is assumed.
   //
   // The file can be specified as a URL of the form:
   //    file:///user/rdm/bla.root or file:/user/rdm/bla.root
   //
   // The file can also be a member of an archive, in which case it is
   // specified as:
   //    multi.zip#file.root or multi.zip#0
   // which will open file.root which is a member of the file multi.zip
   // archive or member 1 from the archive. For more on archive file
   // support see the TArchiveFile class.
   //
   // TFile and its remote access plugins can also be used to open any
   // file, i.e. also non ROOT files, using:
   //    file.tar?filetype=raw
   // This is convenient because the many remote file access plugins allow
   // easy access to/from the many different mass storage systems.
   //
   // The title of the file (ftitle) will be shown by the ROOT browsers.
   //
   // A ROOT file (like a Unix file system) may contain objects and
   // directories. There are no restrictions for the number of levels
   // of directories.
   //
   // A ROOT file is designed such that one can write in the file in pure
   // sequential mode (case of BATCH jobs). In this case, the file may be
   // read sequentially again without using the file index written
   // at the end of the file. In case of a job crash, all the information
   // on the file is therefore protected.
   //
   // A ROOT file can be used interactively. In this case, one has the
   // possibility to delete existing objects and add new ones.
   // When an object is deleted from the file, the freed space is added
   // into the FREE linked list (fFree). The FREE list consists of a chain
   // of consecutive free segments on the file. At the same time, the first
   // 4 bytes of the freed record on the file are overwritten by GAPSIZE
   // where GAPSIZE = -(Number of bytes occupied by the record).
   //
   // Option compress is used to specify the compression level and algorithm:
   //  compress = 100 * algorithm + level
   //  level = 0, objects written to this file will not be compressed.
   //  level = 1, minimal compression level but fast.
   //  ....
   //  level = 9, maximal compression level but slower and might use more memory.
   // (For the currently supported algorithms, the maximum level is 9)
   // If compress is negative it indicates the compression level is not set yet.
   //
   // The enumeration ROOT::ECompressionAlgorithm associates each
   // algorithm with a number. There is a utility function to help
   // to set the value of compress. For example,
   //   ROOT::CompressionSettings(ROOT::kLZMA, 1)
   // will build an integer which will set the compression to use
   // the LZMA algorithm and compression level 1.  These are defined
   // in the header file Compression.h.
   //
   // Note that the compression settings may be changed at any time.
   // The new compression settings will only apply to branches created
   // or attached after the setting is changed and other objects written
   // after the setting is changed.
   //
   // In case the file does not exist or is not a valid ROOT file,
   // it is made a Zombie. One can detect this situation with a code like:
   //    TFile f("file.root");
   //    if (f.IsZombie()) {
   //       std::cout << "Error opening file" << std::endl;
   //       exit(-1);
   //    }
   //
   //  When opening the file, the system checks the validity of this directory.
   //  If something wrong is detected, an automatic Recovery is performed. In
   //  this case, the file is scanned sequentially reading all logical blocks
   //  and attempting to rebuild a correct directory (see TFile::Recover).
   //  One can disable the automatic recovery procedure when reading one
   //  or more files by setting the environment variable "TFile.Recover: 0"
   //  in the system.rootrc file.
   //

   if (!gROOT)
      ::Fatal("TFile::TFile", "ROOT system not initialized");

   // store name without the options as name and title
   TString sfname1 = fname1;
   fNoAnchorInName = kFALSE;
   if (sfname1.Index("?") != kNPOS) {
      TString s = sfname1(0, sfname1.Index("?"));
      SetName(s);
      fNoAnchorInName = kTRUE;
   } else
      SetName(fname1);

   SetTitle(ftitle);

   // accept also URL like "file:..." syntax
   fname1 = fUrl.GetFile();

   // if option contains filetype=raw then go into raw file mode
   fIsRootFile = kTRUE;
   if (strstr(fUrl.GetOptions(), "filetype=raw"))
      fIsRootFile = kFALSE;

   // if option contains filetype=pcm then go into ROOT PCM file mode
   fIsPcmFile = kFALSE;
   if (strstr(fUrl.GetOptions(), "filetype=pcm"))
      fIsPcmFile = kTRUE;

   // Init initialization control flag
   fInitDone   = kFALSE;
   fMustFlush  = kTRUE;

   // We are opening synchronously
   fAsyncHandle = 0;
   fAsyncOpenStatus = kAOSNotAsync;

   TDirectoryFile::Build(this, 0);

   fD            = -1;
   fFree         = 0;
   fVersion      = gROOT->GetVersionInt();  //ROOT version in integer format
   fUnits        = 4;
   fOption       = option;
   fCompress     = compress;
   fWritten      = 0;
   fSumBuffer    = 0;
   fSum2Buffer   = 0;
   fBytesRead    = 0;
   fBytesReadExtra = 0;
   fBytesWrite   = 0;
   fClassIndex   = 0;
   fSeekInfo     = 0;
   fNbytesInfo   = 0;
   fProcessIDs   = 0;
   fNProcessIDs  = 0;
   fOffset       = 0;
   fCacheRead    = 0;
   fCacheReadMap = new TMap();
   fCacheWrite   = 0;
   fReadCalls    = 0;
   SetBit(kBinaryFile, kTRUE);

   fOption.ToUpper();

   fArchiveOffset = 0;
   fIsArchive     = kFALSE;
   fArchive       = 0;
   if (fIsRootFile && !fIsPcmFile && fOption != "NEW" && fOption != "CREATE"
       && fOption != "RECREATE") {
      // If !gPluginMgr then we are at startup and cannot handle plugins
      // as TArchiveFile yet.
      fArchive = gPluginMgr ? TArchiveFile::Open(fUrl.GetUrl(), this) : 0;
      if (fArchive) {
         fname1 = fArchive->GetArchiveName();
         // if no archive member is specified then this TFile is just used
         // to read the archive contents
         if (!strlen(fArchive->GetMemberName()))
            fIsArchive = kTRUE;
      }
   }

   if (fOption == "NET")
      return;

   if (fOption == "WEB") {
      fOption   = "READ";
      fWritable = kFALSE;
      return;
   }

   if (fOption == "NEW")
      fOption = "CREATE";

   Bool_t create   = (fOption == "CREATE") ? kTRUE : kFALSE;
   Bool_t recreate = (fOption == "RECREATE") ? kTRUE : kFALSE;
   Bool_t update   = (fOption == "UPDATE") ? kTRUE : kFALSE;
   Bool_t read     = (fOption == "READ") ? kTRUE : kFALSE;
   if (!create && !recreate && !update && !read) {
      read    = kTRUE;
      fOption = "READ";
   }

   Bool_t devnull = kFALSE;

   if (!fname1 || !fname1[0]) {
      Error("TFile", "file name is not specified");
      goto zombie;
   }

   // support dumping to /dev/null on UNIX
   if (!strcmp(fname1, "/dev/null") &&
       !gSystem->AccessPathName(fname1, kWritePermission)) {
      devnull  = kTRUE;
      create   = kTRUE;
      recreate = kFALSE;
      update   = kFALSE;
      read     = kFALSE;
      fOption  = "CREATE";
      SetBit(kDevNull);
   }

   const char *fname;
   if ((fname = gSystem->ExpandPathName(fname1))) {
      SetName(fname);
      delete [] fname;
      fRealName = GetName();
      fname = fRealName.Data();
   } else {
      Error("TFile", "error expanding path %s", fname1);
      goto zombie;
   }

   if (recreate) {
      if (!gSystem->AccessPathName(fname, kFileExists)) {
         if (gSystem->Unlink(fname) != 0) {
            SysError("TFile", "could not delete %s (errno: %d)",
                     fname, gSystem->GetErrno());
            goto zombie;
         }
      }
      recreate = kFALSE;
      create   = kTRUE;
      fOption  = "CREATE";
   }
   if (create && !devnull && !gSystem->AccessPathName(fname, kFileExists)) {
      Error("TFile", "file %s already exists", fname);
      goto zombie;
   }
   if (update) {
      if (gSystem->AccessPathName(fname, kFileExists)) {
         update = kFALSE;
         create = kTRUE;
      }
      if (update && gSystem->AccessPathName(fname, kWritePermission)) {
         Error("TFile", "no write permission, could not open file %s", fname);
         goto zombie;
      }
   }
   if (read) {
      if (gSystem->AccessPathName(fname, kFileExists)) {
         Error("TFile", "file %s does not exist", fname);
         goto zombie;
      }
      if (gSystem->AccessPathName(fname, kReadPermission)) {
         Error("TFile", "no read permission, could not open file %s", fname);
         goto zombie;
      }
   }

   // Connect to file system stream
   if (create || update) {
#ifndef WIN32
      fD = SysOpen(fname, O_RDWR | O_CREAT, 0644);
#else
      fD = SysOpen(fname, O_RDWR | O_CREAT | O_BINARY, S_IREAD | S_IWRITE);
#endif
      if (fD == -1) {
         SysError("TFile", "file %s can not be opened", fname);
         goto zombie;
      }
      fWritable = kTRUE;
   } else {
#ifndef WIN32
      fD = SysOpen(fname, O_RDONLY, 0644);
#else
      fD = SysOpen(fname, O_RDONLY | O_BINARY, S_IREAD | S_IWRITE);
#endif
      if (fD == -1) {
         SysError("TFile", "file %s can not be opened for reading", fname);
         goto zombie;
      }
      fWritable = kFALSE;
   }

   Init(create);

   return;

zombie:
   // error in file opening occured, make this object a zombie
   {
      R__LOCKGUARD2(gROOTMutex);
      gROOT->GetListOfClosedObjects()->Add(this);
   }
   MakeZombie();
   gDirectory = gROOT;
}

//______________________________________________________________________________
TFile::TFile(const TFile &) : TDirectoryFile(), fInfoCache(0)
{
   // TFile objects can not be copied.

   MayNotUse("TFile::TFile(const TFile &)");
}

//______________________________________________________________________________
TFile::~TFile()
{
   // File destructor.

   Close();

   SafeDelete(fAsyncHandle);
   SafeDelete(fCacheRead);
   SafeDelete(fCacheReadMap);
   SafeDelete(fCacheWrite);
   SafeDelete(fProcessIDs);
   SafeDelete(fFree);
   SafeDelete(fArchive);
   SafeDelete(fInfoCache);
   SafeDelete(fOpenPhases);

   {
      R__LOCKGUARD2(gROOTMutex);
      gROOT->GetListOfClosedObjects()->Remove(this);
      gROOT->GetUUIDs()->RemoveUUID(GetUniqueID());
   }

   if (IsOnHeap()) {
      // Delete object from CINT symbol table so it can not be used anymore.
      // CINT object are always on the heap.
      gInterpreter->ResetGlobalVar(this);
   }

   if (gDebug)
      Info("~TFile", "dtor called for %s [%lx]", GetName(),(Long_t)this);
}

//______________________________________________________________________________
void TFile::Init(Bool_t create)
{
   // Initialize a TFile object.
   // TFile implementations providing asynchronous open functionality need to
   // override this method to run the appropriate checks before calling this
   // standard initialization part. See TXNetFile::Init for an example.

   if (fInitDone)
      // Already called once
      return;
   fInitDone = kTRUE;

   if (!fIsRootFile) {
      gDirectory = gROOT;
      return;
   }

   if (fArchive) {
      if (fOption != "READ") {
         Error("Init", "archive %s can only be opened in read mode", GetName());
         delete fArchive;
         fArchive = 0;
         fIsArchive = kFALSE;
         goto zombie;
      }

      fArchive->OpenArchive();

      if (fIsArchive) return;

      // Make sure the anchor is in the name
      if (!fNoAnchorInName)
         if (!strchr(GetName(),'#'))
            SetName(TString::Format("%s#%s", GetName(), fArchive->GetMemberName()));

      if (fArchive->SetCurrentMember() != -1)
         fArchiveOffset = fArchive->GetMemberFilePosition();
      else {
         Error("Init", "member %s not found in archive %s",
               fArchive->GetMemberName(), fArchive->GetArchiveName());
         delete fArchive;
         fArchive = 0;
         fIsArchive = kFALSE;
         goto zombie;
      }
   }

   Int_t nfree;
   fBEGIN = (Long64_t)kBEGIN;    //First used word in file following the file header

   // make newly opened file the current file and directory
   cd();

   if (create) {
      //*-*---------------NEW file
      fFree        = new TList;
      fEND         = fBEGIN;    //Pointer to end of file
      new TFree(fFree, fBEGIN, Long64_t(kStartBigFile));  //Create new free list

      //*-* Write Directory info
      Int_t namelen= TNamed::Sizeof();
      Int_t nbytes = namelen + TDirectoryFile::Sizeof();
      TKey *key    = new TKey(fName, fTitle, IsA(), nbytes, this);
      fNbytesName  = key->GetKeylen() + namelen;
      fSeekDir     = key->GetSeekKey();
      fSeekFree    = 0;
      fNbytesFree  = 0;
      WriteHeader();
      char *buffer = key->GetBuffer();
      TNamed::FillBuffer(buffer);
      TDirectoryFile::FillBuffer(buffer);
      key->WriteFile();
      delete key;
   } else {
      //*-*----------------UPDATE
      //char *header = new char[kBEGIN];
      char *header = new char[kBEGIN+200];
      Seek(0);
      //ReadBuffer(header, kBEGIN);
      if (ReadBuffer(header, kBEGIN+200)) {
         // ReadBuffer returns kTRUE in case of failure.
         Error("Init","%s failed to read the file type data.",
               GetName());
         delete [] header;
         goto zombie;
      }

      // make sure this is a ROOT file
      if (strncmp(header, "root", 4)) {
         Error("Init", "%s not a ROOT file", GetName());
         delete [] header;
         goto zombie;
      }

      char *buffer = header + 4;    // skip the "root" file identifier
      frombuf(buffer, &fVersion);
      Int_t headerLength;
      frombuf(buffer, &headerLength);
      fBEGIN = (Long64_t)headerLength;
      if (fVersion < 1000000) { //small file
         Int_t send,sfree,sinfo;
         frombuf(buffer, &send);         fEND     = (Long64_t)send;
         frombuf(buffer, &sfree);        fSeekFree= (Long64_t)sfree;
         frombuf(buffer, &fNbytesFree);
         frombuf(buffer, &nfree);
         frombuf(buffer, &fNbytesName);
         frombuf(buffer, &fUnits );
         frombuf(buffer, &fCompress);
         frombuf(buffer, &sinfo);        fSeekInfo = (Long64_t)sinfo;
         frombuf(buffer, &fNbytesInfo);
      } else { // new format to support large files
         frombuf(buffer, &fEND);
         frombuf(buffer, &fSeekFree);
         frombuf(buffer, &fNbytesFree);
         frombuf(buffer, &nfree);
         frombuf(buffer, &fNbytesName);
         frombuf(buffer, &fUnits );
         frombuf(buffer, &fCompress);
         frombuf(buffer, &fSeekInfo);
         frombuf(buffer, &fNbytesInfo);
      }
      if (fBEGIN < 0 || fBEGIN > fEND) {
         // humm fBEGIN is wrong ....
         Error("Init","file %s has an incorrect header length (%lld) or incorrect end of file length (%lld)",
               GetName(),fBEGIN,fEND);
         goto zombie;
      }
      fSeekDir = fBEGIN;
      //*-*-------------Read Free segments structure if file is writable
      if (fWritable) {
         fFree = new TList;
         if (fSeekFree > fBEGIN) {
            ReadFree();
         } else {
            Warning("Init","file %s probably not closed, cannot read free segments",GetName());
         }
      }
      //*-*-------------Read directory info
      // buffer_keyloc is the start of the key record.
      char *buffer_keyloc = 0;

      Int_t nbytes = fNbytesName + TDirectoryFile::Sizeof();
      if ( (nbytes + fBEGIN) > fEND) {
         // humm fBEGIN is wrong ....
         Error("Init","file %s has an incorrect header length (%lld) or incorrect end of file length (%lld)",
              GetName(),fBEGIN+nbytes,fEND);
         goto zombie;
      }
      if (nbytes+fBEGIN > kBEGIN+200) {
         delete [] header;
         header       = new char[nbytes];
         buffer       = header;
         Seek(fBEGIN);
         if (ReadBuffer(buffer,nbytes)) {
            // ReadBuffer returns kTRUE in case of failure.
            Error("Init","%s failed to read the file header information at %lld (size=%d)",
                  GetName(),fBEGIN,nbytes);
            delete [] header;
            goto zombie;
         }
         buffer = header+fNbytesName;
         buffer_keyloc = header;
      } else {
         buffer = header+fBEGIN+fNbytesName;
         buffer_keyloc = header+fBEGIN;
      }
      Version_t version,versiondir;
      frombuf(buffer,&version); versiondir = version%1000;
      fDatimeC.ReadBuffer(buffer);
      fDatimeM.ReadBuffer(buffer);
      frombuf(buffer, &fNbytesKeys);
      frombuf(buffer, &fNbytesName);
      if (version > 1000) {
         frombuf(buffer, &fSeekDir);
         frombuf(buffer, &fSeekParent);
         frombuf(buffer, &fSeekKeys);
      } else {
         Int_t sdir,sparent,skeys;
         frombuf(buffer, &sdir);    fSeekDir    = (Long64_t)sdir;
         frombuf(buffer, &sparent); fSeekParent = (Long64_t)sparent;
         frombuf(buffer, &skeys);   fSeekKeys   = (Long64_t)skeys;
      }
      if (versiondir > 1) fUUID.ReadBuffer(buffer);

      //*-*---------read TKey::FillBuffer info
      buffer_keyloc += sizeof(Int_t); // Skip NBytes;
      Version_t keyversion;
      frombuf(buffer_keyloc, &keyversion);
      // Skip ObjLen, DateTime, KeyLen, Cycle, SeekKey, SeekPdir
      if (keyversion > 1000) {
         // Large files
         buffer_keyloc += 2*sizeof(Int_t)+2*sizeof(Short_t)+2*sizeof(Long64_t);
      } else {
         buffer_keyloc += 2*sizeof(Int_t)+2*sizeof(Short_t)+2*sizeof(Int_t);
      }
      TString cname;
      cname.ReadBuffer(buffer_keyloc);
      cname.ReadBuffer(buffer_keyloc); // fName.ReadBuffer(buffer); file may have been renamed
      fTitle.ReadBuffer(buffer_keyloc);
      delete [] header;
      if (fNbytesName < 10 || fNbytesName > 10000) {
         Error("Init","cannot read directory info of file %s", GetName());
         goto zombie;
      }

      //*-* -------------Check if file is truncated
      Long64_t size;
      if ((size = GetSize()) == -1) {
         Error("Init", "cannot stat the file %s", GetName());
         goto zombie;
      }

      //*-* -------------Check if, in case of inconsistencies, we are requested to
      //*-* -------------attempt recovering the file
      Bool_t tryrecover = (gEnv->GetValue("TFile.Recover", 1) == 1) ? kTRUE : kFALSE;

      //*-* -------------Read keys of the top directory
      if (fSeekKeys > fBEGIN && fEND <= size) {
         //normal case. Recover only if file has no keys
         TDirectoryFile::ReadKeys(kFALSE);
         gDirectory = this;
         if (!GetNkeys()) {
            if (tryrecover) {
               Recover();
            } else {
               Error("Init", "file %s has no keys", GetName());
               goto zombie;
            }
         }
      } else if ((fBEGIN+nbytes == fEND) && (fEND == size)) {
         //the file might be open by another process and nothing written to the file yet
         Warning("Init","file %s has no keys", GetName());
         gDirectory = this;
      } else {
         //something had been written to the file. Trailer is missing, must recover
         if (fEND > size) {
            if (tryrecover) {
               Error("Init","file %s is truncated at %lld bytes: should be %lld, "
                     "trying to recover", GetName(), size, fEND);
            } else {
               Error("Init","file %s is truncated at %lld bytes: should be %lld",
                     GetName(), size, fEND);
               goto zombie;
            }
         } else {
            if (tryrecover) {
               Warning("Init","file %s probably not closed, "
                       "trying to recover", GetName());
            } else {
               Warning("Init","file %s probably not closed", GetName());
               goto zombie;
            }
         }
         Int_t nrecov = Recover();
         if (nrecov) {
            Warning("Init", "successfully recovered %d keys", nrecov);
         } else {
            Warning("Init", "no keys recovered, file has been made a Zombie");
            goto zombie;
         }
      }
   }

   {
      R__LOCKGUARD2(gROOTMutex);
      gROOT->GetListOfFiles()->Add(this);
      gROOT->GetUUIDs()->AddUUID(fUUID,this);
   }

   // Create StreamerInfo index
   {
      Int_t lenIndex = gROOT->GetListOfStreamerInfo()->GetSize()+1;
      if (lenIndex < 5000) lenIndex = 5000;
      fClassIndex = new TArrayC(lenIndex);
      if (fgReadInfo) {
         if (fSeekInfo > fBEGIN) {
            ReadStreamerInfo();
            if (IsZombie()) {
               R__LOCKGUARD2(gROOTMutex);
               gROOT->GetListOfFiles()->Remove(this);
               goto zombie;
            }
         } else if (fVersion != gROOT->GetVersionInt() && fVersion > 30000) {
            Warning("Init","no StreamerInfo found in %s therefore preventing schema evolution when reading this file.",GetName());
         }
      }
   }

   // Count number of TProcessIDs in this file
   {
      TIter next(fKeys);
      TKey *key;
      while ((key = (TKey*)next())) {
         if (!strcmp(key->GetClassName(),"TProcessID")) fNProcessIDs++;
      }
      fProcessIDs = new TObjArray(fNProcessIDs+1);
   }
   return;

zombie:
   {
      R__LOCKGUARD2(gROOTMutex);
      gROOT->GetListOfClosedObjects()->Add(this);
   }
   // error in file opening occured, make this object a zombie
   fWritable = kFALSE;
   MakeZombie();
   gDirectory = gROOT;
}

//______________________________________________________________________________
void TFile::Close(Option_t *option)
{
   // Close a file.
   // If option == "R", all TProcessIDs referenced by this file are deleted.
   // Calling TFile::Close("R") might be necessary in case one reads a long list
   // of files having TRef, writing some of the referenced objects or TRef
   // to a new file. If the TRef or referenced objects of the file being closed
   // will not be referenced again, it is possible to minimize the size
   // of the TProcessID data structures in memory by forcing a delete of
   // the unused TProcessID.

   TString opt = option;

   opt.ToLower();

   if (!IsOpen()) return;

   if (fIsArchive || !fIsRootFile) {
      FlushWriteCache();
      SysClose(fD);
      fD = -1;

      if (gMonitoringWriter)
         gMonitoringWriter->SendFileCloseEvent(this);

      return;
   }

   if (IsWritable()) {
      WriteStreamerInfo();
   }

   // Finish any concurrent I/O operations before we close the file handles.
   if (fCacheRead) fCacheRead->Close();
   {
      TIter iter(fCacheReadMap);
      TObject *key = 0;
      while ((key = iter()) != 0) {
         TFileCacheRead *cache = dynamic_cast<TFileCacheRead *>(fCacheReadMap->GetValue(key));
         cache->Close();
      }
   }

   // Delete all supported directories structures from memory
   // If gDirectory points to this object or any of the nested
   // TDirectoryFile, TDirectoryFile::Close will induce the proper cd.
   fMustFlush = kFALSE; // Make sure there is only one Flush.
   TDirectoryFile::Close();

   if (IsWritable()) {
      TFree *f1 = (TFree*)fFree->First();
      if (f1) {
         WriteFree();       //*-*- Write free segments linked list
         WriteHeader();     //*-*- Now write file header ; this forces a Flush/fsync
      } else {
         Flush();
      }
   }
   fMustFlush = kTRUE;

   FlushWriteCache();

   if (gMonitoringWriter)
      gMonitoringWriter->SendFileCloseEvent(this);

   delete fClassIndex;
   fClassIndex = 0;

   // Delete free segments from free list (but don't delete list header)
   if (fFree) {
      fFree->Delete();
   }

   if (IsOpen()) {
      SysClose(fD);
      fD = -1;
   }

   fWritable = kFALSE;

   // delete the TProcessIDs
   TList pidDeleted;
   TIter next(fProcessIDs);
   TProcessID *pid;
   while ((pid = (TProcessID*)next())) {
      if (!pid->DecrementCount()) {
         if (pid != TProcessID::GetSessionProcessID()) pidDeleted.Add(pid);
      } else if(opt.Contains("r")) {
         pid->Clear();
      }
   }
   pidDeleted.Delete();

   if (!IsZombie()) {
      R__LOCKGUARD2(gROOTMutex);
      gROOT->GetListOfFiles()->Remove(this);
      gROOT->GetListOfBrowsers()->RecursiveRemove(this);
      gROOT->GetListOfClosedObjects()->Add(this);
   } else {
      // If we are a zombie, we are already in the list of closed objects.
   }
}

//____________________________________________________________________________________
TKey* TFile::CreateKey(TDirectory* mother, const TObject* obj, const char* name, Int_t bufsize)
{
   // Creates key for object and converts data to buffer.

   return new TKey(obj, name, bufsize, mother);
}

//____________________________________________________________________________________
TKey* TFile::CreateKey(TDirectory* mother, const void* obj, const TClass* cl, const char* name, Int_t bufsize)
{
   // Creates key for object and converts data to buffer.

   return new TKey(obj, cl, name, bufsize, mother);
}

//____________________________________________________________________________________
TFile *&TFile::CurrentFile()
{
   // Return the current ROOT file if any.
   // Note that if 'cd' has been called on a TDirectory that does not belong to a file,
   // gFile will be unchanged and still points to the file of the previous current
   // directory that was a file.

   static TFile *currentFile = 0;
   if (!gThreadTsd)
      return currentFile;
   else
      return *(TFile**)(*gThreadTsd)(&currentFile,ROOT::kFileThreadSlot);
}

//______________________________________________________________________________
void TFile::Delete(const char *namecycle)
{
   // Delete object namecycle.
   // Namecycle identifies an object in the top directory of the file
   //   namecycle has the format name;cycle
   //   name  = * means all
   //   cycle = * means all cycles (memory and keys)
   //   cycle = "" or cycle = 9999 ==> apply to a memory object
   //   When name=* use T* to delete subdirectories also
   //
   // Examples:
   //     foo   : delete object named foo in memory
   //     foo;1 : delete cycle 1 of foo on file
   //     foo;* : delete all cycles of foo on disk and also from memory
   //     *;2   : delete all objects on file having the cycle 2
   //     *;*   : delete all objects from memory and file
   //    T*;*   : delete all objects from memory and file and all subdirectories

   if (gDebug)
      Info("Delete", "deleting name = %s", namecycle);

   TDirectoryFile::Delete(namecycle);
}

//______________________________________________________________________________
void TFile::Draw(Option_t *option)
{
   // Fill Graphics Structure and Paint.
   // Loop on all objects (memory or file) and all subdirectories.

   GetList()->R__FOR_EACH(TObject,Draw)(option);
}

//______________________________________________________________________________
void TFile::DrawMap(const char *keys, Option_t *option)
{
   // Draw map of objects in this file.

   TPluginHandler *h;
   if ((h = gROOT->GetPluginManager()->FindHandler("TFileDrawMap"))) {
      if (h->LoadPlugin() == -1)
         return;
      h->ExecPlugin(3, this, keys, option);
   }
}

//______________________________________________________________________________
void TFile::Flush()
{
   // Synchronize a file's in-core and on-disk states.
   if (IsOpen() && fWritable) {
      FlushWriteCache();
      if (SysSync(fD) < 0) {
         // Write the system error only once for this file
         SetBit(kWriteError); SetWritable(kFALSE);
         SysError("Flush", "error flushing file %s", GetName());
      }
   }
}

//______________________________________________________________________________
Bool_t TFile::FlushWriteCache()
{
   // Flush the write cache if active.
   // Return kTRUE in case of error

   if (fCacheWrite && IsOpen() && fWritable)
      return fCacheWrite->Flush();
   return kFALSE;
}

//______________________________________________________________________________
void TFile::FillBuffer(char *&buffer)
{
   // Encode file output buffer.
   // The file output buffer contains only the FREE data record.

   Version_t version = TFile::Class_Version();
   tobuf(buffer, version);
}

//______________________________________________________________________________
Int_t TFile::GetBestBuffer() const
{
   // Return the best buffer size of objects on this file.
   // The best buffer size is estimated based on the current mean value
   // and standard deviation of all objects written so far to this file.
   // Returns mean value + one standard deviation.

   if (!fWritten) return TBuffer::kInitialSize;
   Double_t mean = fSumBuffer/fWritten;
   Double_t rms2 = TMath::Abs(fSum2Buffer/fSumBuffer -mean*mean);
   return (Int_t)(mean + sqrt(rms2));
}

//______________________________________________________________________________
Float_t TFile::GetCompressionFactor()
{
   // Return the file compression factor.
   // Add total number of compressed/uncompressed bytes for each key.
   // return ratio of the two.

   Short_t  keylen;
   UInt_t   datime;
   Int_t    nbytes, objlen, nwh = 64;
   char    *header = new char[fBEGIN];
   char    *buffer;
   Long64_t   idcur = fBEGIN;
   Float_t comp,uncomp;
   comp = uncomp = fBEGIN;

   while (idcur < fEND-100) {
      Seek(idcur);
      if (ReadBuffer(header, nwh)) {
         // ReadBuffer returns kTRUE in case of failure.
//         Error("GetCompressionFactor","%s failed to read the key header information at %lld (size=%d).",
//               GetName(),idcur,nwh);
         break;
      }
      buffer=header;
      frombuf(buffer, &nbytes);
      if (nbytes < 0) {
         idcur -= nbytes;
         Seek(idcur);
         continue;
      }
      if (nbytes == 0) break; //this may happen when the file is corrupted
      Version_t versionkey;
      frombuf(buffer, &versionkey);
      frombuf(buffer, &objlen);
      frombuf(buffer, &datime);
      frombuf(buffer, &keylen);
      if (!objlen) objlen = nbytes-keylen;
      comp   += nbytes;
      uncomp += keylen + objlen;
      idcur  += nbytes;
   }
   delete [] header;
   return uncomp/comp;
}

//______________________________________________________________________________
Int_t TFile::GetErrno() const
{
   // Method returning errno. Is overriden in TRFIOFile.

   return TSystem::GetErrno();
}

//______________________________________________________________________________
void TFile::ResetErrno() const
{
   // Method resetting the errno. Is overridden in TRFIOFile.

   TSystem::ResetErrno();
}

//______________________________________________________________________________
TFileCacheRead *TFile::GetCacheRead(TObject* tree) const
{
   // Return a pointer to the current read cache.

   if (!tree) {
      if (!fCacheRead && fCacheReadMap->GetSize() == 1) {
         TIter next(fCacheReadMap);
         return (TFileCacheRead *)fCacheReadMap->GetValue(next());
      }
      return fCacheRead;
   }
   TFileCacheRead *cache = (TFileCacheRead *)fCacheReadMap->GetValue(tree);
   if (!cache) return fCacheRead;
   return cache;
}

//______________________________________________________________________________
TFileCacheWrite *TFile::GetCacheWrite() const
{
   // Return a pointer to the current write cache.

   return fCacheWrite;
}

//______________________________________________________________________________
Int_t TFile::GetRecordHeader(char *buf, Long64_t first, Int_t maxbytes, Int_t &nbytes, Int_t &objlen, Int_t &keylen)
{
   // Read the logical record header starting at position first.
   // Maxbytes bytes are read into buf the function reads nread bytes
   // where nread is the minimum of maxbytes and the number of bytes
   // before the end of file. The function 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

   nbytes = 0;
   objlen = 0;
   keylen = 0;
   if (first < fBEGIN) return 0;
   if (first > fEND)   return 0;
   Seek(first);
   Int_t nread = maxbytes;
   if (first+maxbytes > fEND) nread = fEND-maxbytes;
   if (nread < 4) {
      Warning("GetRecordHeader","%s: parameter maxbytes = %d must be >= 4",
              GetName(), nread);
      return nread;
   }
   if (ReadBuffer(buf,nread)) {
      // ReadBuffer return kTRUE in case of failure.
      Warning("GetRecordHeader","%s: failed to read header data (maxbytes = %d)",
              GetName(), nread);
      return nread;
   }
   Version_t versionkey;
   Short_t  klen;
   UInt_t   datime;
   Int_t    nb,olen;
   char *buffer = buf;
   frombuf(buffer,&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(buffer, &versionkey);
   frombuf(buffer, &olen);
   frombuf(buffer, &datime);
   frombuf(buffer, &klen);
   if (!olen) olen = nbytes-klen;
   objlen = olen;
   keylen = klen;
   return nread;
}

//______________________________________________________________________________
Long64_t TFile::GetSize() const
{
   // Returns the current file size. Returns -1 in case the file could not
   // be stat'ed.

   Long64_t size;

   if (fArchive && fArchive->GetMember()) {
      size = fArchive->GetMember()->GetDecompressedSize();
   } else {
      Long_t id, flags, modtime;
      if (const_cast<TFile*>(this)->SysStat(fD, &id, &size, &flags, &modtime)) {
         Error("GetSize", "cannot stat the file %s", GetName());
         return -1;
      }
   }
   return size;
}

//______________________________________________________________________________
const TList *TFile::GetStreamerInfoCache()
{
   // Returns the cached list of StreamerInfos used in this file.

   return fInfoCache ?  fInfoCache : (fInfoCache=GetStreamerInfoList());
}

//______________________________________________________________________________
TList *TFile::GetStreamerInfoList()
{
   // Read the list of TStreamerInfo objects written to this file.
   // The function returns a TList. It is the user'responsability
   // to delete the list created by this function.
   //
   // Using the list, one can access additional information,eg:
   //   TFile f("myfile.root");
   //   TList *list = f.GetStreamerInfoList();
   //   TStreamerInfo *info = (TStreamerInfo*)list->FindObject("MyClass");
   //   Int_t classversionid = info->GetClassVersion();
   //   delete list;

   if (fIsPcmFile) return 0; // No schema evolution for ROOT PCM files.

   TList *list = 0;
   if (fSeekInfo) {
      TDirectory::TContext ctxt(this); // gFile and gDirectory used in ReadObj
      TKey *key = new TKey(this);
      char *buffer = new char[fNbytesInfo+1];
      char *buf    = buffer;
      Seek(fSeekInfo);
      if (ReadBuffer(buf,fNbytesInfo)) {
         // ReadBuffer returns kTRUE in case of failure.
         Warning("GetRecordHeader","%s: failed to read the StreamerInfo data from disk.",
                 GetName());
         return 0;
      }
      key->ReadKeyBuffer(buf);
      list = dynamic_cast<TList*>(key->ReadObjWithBuffer(buffer));
      if (list) list->SetOwner();
      delete [] buffer;
      delete key;
   } else {
      list = (TList*)Get("StreamerInfo"); //for versions 2.26 (never released)
   }

   if (list == 0) {
      Info("GetStreamerInfoList", "cannot find the StreamerInfo record in file %s",
           GetName());
      return 0;
   }

   return list;
}

//______________________________________________________________________________
void TFile::ls(Option_t *option) const
{
   // List File contents.
   // Indentation is used to identify the file tree.
   // Subdirectories are listed first, then objects in memory,
   // then objects on the file.

   TROOT::IndentLevel();
   std::cout <<ClassName()<<"**\t\t"<<GetName()<<"\t"<<GetTitle()<<std::endl;
   TROOT::IncreaseDirLevel();
   TDirectoryFile::ls(option);
   TROOT::DecreaseDirLevel();
}

//______________________________________________________________________________
Bool_t TFile::IsOpen() const
{
   // Returns kTRUE in case file is open and kFALSE if file is not open.

   return fD == -1 ? kFALSE : kTRUE;
}

//______________________________________________________________________________
void TFile::MakeFree(Long64_t first, Long64_t last)
{
   // Mark unused bytes on the file.
   // The list of free segments is in the fFree linked list.
   // When an object is deleted from the file, the freed space is added
   // into the FREE linked list (fFree). The FREE list consists of a chain
   // of consecutive free segments on the file. At the same time, the first
   // 4 bytes of the freed record on the file are overwritten by GAPSIZE
   // where GAPSIZE = -(Number of bytes occupied by the record).

   TFree *f1      = (TFree*)fFree->First();
   if (!f1) return;
   TFree *newfree = f1->AddFree(fFree,first,last);
   if(!newfree) return;
   Long64_t nfirst = newfree->GetFirst();
   Long64_t nlast  = newfree->GetLast();
   Long64_t nbytesl= nlast-nfirst+1;
   if (nbytesl > 2000000000) nbytesl = 2000000000;
   Int_t nbytes    = -Int_t (nbytesl);
   Int_t nb        = sizeof(Int_t);
   char * buffer   = new char[nb];
   char * psave    = buffer;
   tobuf(buffer, nbytes);
   if (last == fEND-1) fEND = nfirst;
   Seek(nfirst);
   // We could not update the meta data for this block on the file.
   // This is not fatal as this only means that we won't get it 'right'
   // if we ever need to Recover the file before the block is actually
   // (attempted to be reused.
   // coverity[unchecked_value]
   WriteBuffer(psave, nb);
   if (fMustFlush) Flush();
   delete [] psave;
}

//______________________________________________________________________________
void TFile::Map()
{
   // List the contents of a file sequentially.
   // For each logical record found, it prints:
   //  Date/Time  Record_Adress Logical_Record_Length  ClassName  CompressionFactor
   //
   //  Example of output
   //  20010404/150437  At:64        N=150       TFile
   //  20010404/150440  At:214       N=28326     TBasket        CX =  1.13
   //  20010404/150440  At:28540     N=29616     TBasket        CX =  1.08
   //  20010404/150440  At:58156     N=29640     TBasket        CX =  1.08
   //  20010404/150440  At:87796     N=29076     TBasket        CX =  1.10
   //  20010404/150440  At:116872    N=10151     TBasket        CX =  3.15
   //  20010404/150441  At:127023    N=28341     TBasket        CX =  1.13
   //  20010404/150441  At:155364    N=29594     TBasket        CX =  1.08
   //  20010404/150441  At:184958    N=29616     TBasket        CX =  1.08
   //  20010404/150441  At:214574    N=29075     TBasket        CX =  1.10
   //  20010404/150441  At:243649    N=9583      TBasket        CX =  3.34
   //  20010404/150442  At:253232    N=28324     TBasket        CX =  1.13
   //  20010404/150442  At:281556    N=29641     TBasket        CX =  1.08
   //  20010404/150442  At:311197    N=29633     TBasket        CX =  1.08
   //  20010404/150442  At:340830    N=29091     TBasket        CX =  1.10
   //  20010404/150442  At:369921    N=10341     TBasket        CX =  3.09
   //  20010404/150442  At:380262    N=509       TH1F           CX =  1.93
   //  20010404/150442  At:380771    N=1769      TH2F           CX =  4.32
   //  20010404/150442  At:382540    N=1849      TProfile       CX =  1.65
   //  20010404/150442  At:384389    N=18434     TNtuple        CX =  4.51
   //  20010404/150442  At:402823    N=307       KeysList
   //  20010404/150443  At:403130    N=4548      StreamerInfo   CX =  3.65
   //  20010404/150443  At:407678    N=86        FreeSegments
   //  20010404/150443  At:407764    N=1         END

   Short_t  keylen,cycle;
   UInt_t   datime;
   Int_t    nbytes,date,time,objlen,nwheader;
   date = 0;
   time = 0;
   Long64_t seekkey,seekpdir;
   char    *buffer;
   char     nwhc;
   Long64_t idcur = fBEGIN;

   nwheader = 64;
   Int_t nread = nwheader;

   char header[kBEGIN];
   char classname[512];

   while (idcur < fEND) {
      Seek(idcur);
      if (idcur+nread >= fEND) nread = fEND-idcur-1;
      if (ReadBuffer(header, nread)) {
         // ReadBuffer returns kTRUE in case of failure.
         Warning("Map","%s: failed to read the key data from disk at %lld.",
                 GetName(),idcur);
         break;
      }

      buffer=header;
      frombuf(buffer, &nbytes);
      if (!nbytes) {
         Printf("Address = %lld\tNbytes = %d\t=====E R R O R=======", idcur, nbytes);
         date = 0; time = 0;
         break;
      }
      if (nbytes < 0) {
         Printf("Address = %lld\tNbytes = %d\t=====G A P===========", idcur, nbytes);
         idcur -= nbytes;
         Seek(idcur);
         continue;
      }
      Version_t versionkey;
      frombuf(buffer, &versionkey);
      frombuf(buffer, &objlen);
      frombuf(buffer, &datime);
      frombuf(buffer, &keylen);
      frombuf(buffer, &cycle);
      if (versionkey > 1000) {
         frombuf(buffer, &seekkey);
         frombuf(buffer, &seekpdir);
      } else {
         Int_t skey,sdir;
         frombuf(buffer, &skey);  seekkey  = (Long64_t)skey;
         frombuf(buffer, &sdir);  seekpdir = (Long64_t)sdir;
      }
      frombuf(buffer, &nwhc);
      for (int i = 0;i < nwhc; i++) frombuf(buffer, &classname[i]);
      classname[(int)nwhc] = '\0'; //cast to avoid warning with gcc3.4
      if (idcur == fSeekFree) strlcpy(classname,"FreeSegments",512);
      if (idcur == fSeekInfo) strlcpy(classname,"StreamerInfo",512);
      if (idcur == fSeekKeys) strlcpy(classname,"KeysList",512);
      TDatime::GetDateTime(datime, date, time);
      if (objlen != nbytes-keylen) {
         Float_t cx = Float_t(objlen+keylen)/Float_t(nbytes);
         Printf("%d/%06d  At:%lld  N=%-8d  %-14s CX = %5.2f",date,time,idcur,nbytes,classname,cx);
      } else {
         Printf("%d/%06d  At:%lld  N=%-8d  %-14s",date,time,idcur,nbytes,classname);
      }
      idcur += nbytes;
   }
   Printf("%d/%06d  At:%lld  N=%-8d  %-14s",date,time,idcur,1,"END");
}

//______________________________________________________________________________
void TFile::Paint(Option_t *option)
{
   // Paint all objects in the file.

   GetList()->R__FOR_EACH(TObject,Paint)(option);
}

//______________________________________________________________________________
void TFile::Print(Option_t *option) const
{
   // Print all objects in the file.

   Printf("TFile: name=%s, title=%s, option=%s", GetName(), GetTitle(), GetOption());
   GetList()->R__FOR_EACH(TObject,Print)(option);
}

//______________________________________________________________________________
Bool_t TFile::ReadBuffer(char *buf, Long64_t pos, Int_t len)
{
   // Read a buffer from the file at the offset 'pos' in the file.
   // Returns kTRUE in case of failure.
   // Compared to ReadBuffer(char*, Int_t), this routine does _not_
   // change the cursor on the physical file representation (fD)
   // if the data is in this TFile's cache.

   if (IsOpen()) {

      SetOffset(pos);

      Int_t st;
      Double_t start = 0;
      if (gPerfStats != 0) start = TTimeStamp();

      if ((st = ReadBufferViaCache(buf, len))) {
         if (st == 2)
            return kTRUE;
         return kFALSE;
      }

      Seek(pos);
      ssize_t siz;

      while ((siz = SysRead(fD, buf, len)) < 0 && GetErrno() == EINTR)
         ResetErrno();

      if (siz < 0) {
         SysError("ReadBuffer", "error reading from file %s", GetName());
         return kTRUE;
      }
      if (siz != len) {
         Error("ReadBuffer", "error reading all requested bytes from file %s, got %ld of %d",
               GetName(), (Long_t)siz, len);
         return kTRUE;
      }
      fBytesRead  += siz;
      fgBytesRead += siz;
      fReadCalls++;
      fgReadCalls++;

      if (gMonitoringWriter)
         gMonitoringWriter->SendFileReadProgress(this);
      if (gPerfStats != 0) {
         gPerfStats->FileReadEvent(this, len, start);
      }
      return kFALSE;
   }
   return kTRUE;
}

//______________________________________________________________________________
Bool_t TFile::ReadBuffer(char *buf, Int_t len)
{
   // Read a buffer from the file. This is the basic low level read operation.
   // Returns kTRUE in case of failure.

   if (IsOpen()) {

      Int_t st;
      if ((st = ReadBufferViaCache(buf, len))) {
         if (st == 2)
            return kTRUE;
         return kFALSE;
      }

      ssize_t siz;
      Double_t start = 0;

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

      while ((siz = SysRead(fD, buf, len)) < 0 && GetErrno() == EINTR)
         ResetErrno();

      if (siz < 0) {
         SysError("ReadBuffer", "error reading from file %s", GetName());
         return kTRUE;
      }
      if (siz != len) {
         Error("ReadBuffer", "error reading all requested bytes from file %s, got %ld of %d",
               GetName(), (Long_t)siz, len);
         return kTRUE;
      }
      fBytesRead  += siz;
      fgBytesRead += siz;
      fReadCalls++;
      fgReadCalls++;

      if (gMonitoringWriter)
         gMonitoringWriter->SendFileReadProgress(this);
      if (gPerfStats != 0) {
         gPerfStats->FileReadEvent(this, len, start);
      }
      return kFALSE;
   }
   return kTRUE;
}

//______________________________________________________________________________
Bool_t TFile::ReadBuffers(char *buf, Long64_t *pos, Int_t *len, Int_t nbuf)
{
   // Read the nbuf blocks described in arrays pos and len,
   // where pos[i] is the seek position of block i of length len[i].
   // Note that for nbuf=1, this call is equivalent to TFile::ReafBuffer.
   // This function is overloaded by TNetFile, TWebFile, etc.
   // Returns kTRUE in case of failure.

   // called with buf=0, from TFileCacheRead to pass list of readahead buffers
   if (!buf) {
      for (Int_t j = 0; j < nbuf; j++) {
         if (ReadBufferAsync(pos[j], len[j])) {
             return kTRUE;
         }
      }
      return kFALSE;
   }

   Int_t k = 0;
   Bool_t result = kTRUE;
   TFileCacheRead *old = fCacheRead;
   fCacheRead = 0;
   Long64_t curbegin = pos[0];
   Long64_t cur;
   char *buf2 = 0;
   Int_t i = 0, n = 0;
   while (i < nbuf) {
      cur = pos[i]+len[i];
      Bool_t bigRead = kTRUE;
      if (cur -curbegin < fgReadaheadSize) {n++; i++; bigRead = kFALSE;}
      if (bigRead || (i>=nbuf)) {
         if (n == 0) {
            //if the block to read is about the same size as the read-ahead buffer
            //we read the block directly
            Seek(pos[i]);
            result = ReadBuffer(&buf[k], len[i]);
            if (result) break;
            k += len[i];
            i++;
         } else {
            //otherwise we read all blocks that fit in the read-ahead buffer
            Seek(curbegin);
            if (buf2 == 0) buf2 = new char[fgReadaheadSize];
            //we read ahead
            Long64_t nahead = pos[i-1]+len[i-1]-curbegin;
            result = ReadBuffer(buf2, nahead);
            if (result) break;
            //now copy from the read-ahead buffer to the cache
            Int_t kold = k;
            for (Int_t j=0;j<n;j++) {
               memcpy(&buf[k],&buf2[pos[i-n+j]-curbegin],len[i-n+j]);
               k += len[i-n+j];
            }
            Int_t nok = k-kold;
            Long64_t extra = nahead-nok;
            fBytesReadExtra += extra;
            fBytesRead      -= extra;
            fgBytesRead     -= extra;
            n = 0;
         }
         curbegin = pos[i];
      }
   }
   if (buf2) delete [] buf2;
   fCacheRead = old;
   return result;
}

//______________________________________________________________________________
Int_t TFile::ReadBufferViaCache(char *buf, Int_t len)
{
   // Read buffer via cache. Returns 0 if the requested block is
   // not in the cache, 1 in case read via cache was successful,
   // 2 in case read via cache failed.

   Long64_t off = GetRelOffset();
   if (fCacheRead) {
      Int_t st = fCacheRead->ReadBuffer(buf, off, len);
      if (st < 0)
         return 2;  // failure reading
      else if (st == 1) {
         // fOffset might have been changed via TFileCacheRead::ReadBuffer(), reset it
         SetOffset(off + len);
         return 1;
      }
      // fOffset might have been changed via TFileCacheRead::ReadBuffer(), reset it
      Seek(off);
   } else {
      // if write cache is active check if data still in write cache
      if (fWritable && fCacheWrite) {
         if (fCacheWrite->ReadBuffer(buf, off, len) == 0) {
            SetOffset(off + len);
            return 1;
         }
         // fOffset might have been changed via TFileCacheWrite::ReadBuffer(), reset it
         SetOffset(off);
      }
   }

   return 0;
}

//______________________________________________________________________________
void TFile::ReadFree()
{
   // Read the FREE linked list.
   // Every file has a linked list (fFree) of free segments.
   // This linked list has been written on the file via WriteFree
   // as a single data record.

   // Avoid problem with file corruption.
   if (fNbytesFree < 0 || fNbytesFree > fEND) {
      fNbytesFree = 0;
      return;
   }
   TKey *headerfree = new TKey(fSeekFree, fNbytesFree, this);
   headerfree->ReadFile();
   char *buffer = headerfree->GetBuffer();
   headerfree->ReadKeyBuffer(buffer);
   buffer = headerfree->GetBuffer();
   while (1) {
      TFree *afree = new TFree();
      afree->ReadBuffer(buffer);
      fFree->Add(afree);
      if (afree->GetLast() > fEND) break;
   }
   delete headerfree;
}

//______________________________________________________________________________
TProcessID  *TFile::ReadProcessID(UShort_t pidf)
{
   //The TProcessID with number pidf is read from this file.
   //If the object is not already entered in the gROOT list, it is added.

   TProcessID *pid = 0;
   TObjArray *pids = GetListOfProcessIDs();
   if (pidf < pids->GetSize()) pid = (TProcessID *)pids->UncheckedAt(pidf);
   if (pid) {
      pid->CheckInit();
      return pid;
   }

   //check if fProcessIDs[uid] is set in file
   //if not set, read the process uid from file
   char pidname[32];
   snprintf(pidname,32,"ProcessID%d",pidf);
   pid = (TProcessID *)Get(pidname);
   if (gDebug > 0) {
      printf("ReadProcessID, name=%s, file=%s, pid=%lx\n",pidname,GetName(),(Long_t)pid);
   }
   if (!pid) {
      //file->Error("ReadProcessID","Cannot find %s in file %s",pidname,file->GetName());
      return pid;
   }
      //check that a similar pid is not already registered in fgPIDs
   TObjArray *pidslist = TProcessID::GetPIDs();
   TIter next(pidslist);
   TProcessID *p;
   while ((p = (TProcessID*)next())) {
      if (!strcmp(p->GetTitle(),pid->GetTitle())) {
         delete pid;
         pids->AddAtAndExpand(p,pidf);
         p->IncrementCount();
         return p;
      }
   }
   pids->AddAtAndExpand(pid,pidf);
   pid->IncrementCount();
   pidslist->Add(pid);
   Int_t ind = pidslist->IndexOf(pid);
   pid->SetUniqueID((UInt_t)ind);
   return pid;
}


//______________________________________________________________________________
Int_t TFile::Recover()
{
   // Attempt to recover file if not correctly closed.
   // The function returns the number of keys that have been recovered.
   // If no keys can be recovered, the file will be declared Zombie by
   // the calling function. This function is automatically called when
   // opening a file.
   //
   // If the file is open in read only mode, the file is not modified.
   // If open in update mode and the function finds something to recover,
   //  a new directory header is written to the file. When opening the file gain
   //  no message from Recover will be reported.
   // If keys have been recovered, the file is usable and you can safely
   // read the corresponding objects.
   // If the file is not usable (a zombie), you can test for this case
   // with code like:
   //   TFile f("myfile.root");
   //   if (f.IsZombie()) {file is unusable)
   // If the file has been recovered, the bit kRecovered is set in the TFile object in memory.
   // You can test if the file has been recovered with
   //   if (f.TestBit(TFile::kRecovered)) {.. the file has been recovered}
   //
   // When writing TTrees to a file, it is important to save the Tree header
   // at regular intervals (see TTree::AutoSave). If a file containing a Tree
   // is recovered, the last Tree header written to the file will be used.
   // In this case all the entries in all the branches written before writing
   // the header are valid entries.
   //
   // One can disable the automatic recovery procedure by setting
   // TFile.Recover 0
   // in the system.rootrc file.

   Short_t  keylen,cycle;
   UInt_t   datime;
   Int_t    nbytes,date,time,objlen,nwheader;
   Long64_t seekkey,seekpdir;
   char     header[1024];
   char    *buffer, *bufread;
   char     nwhc;
   Long64_t idcur = fBEGIN;

   Long64_t size;
   if ((size = GetSize()) == -1) {
      Error("Recover", "cannot stat the file %s", GetName());
      return 0;
   }

   fEND = Long64_t(size);

   if (fWritable && !fFree) fFree  = new TList;

   TKey *key;
   Int_t nrecov = 0;
   nwheader = 1024;
   Int_t nread = nwheader;

   while (idcur < fEND) {
      Seek(idcur);
      if (idcur+nread >= fEND) nread = fEND-idcur-1;
      if (ReadBuffer(header, nread)) {
         // ReadBuffer returns kTRUE in case of failure.
         Error("Recover","%s: failed to read the key data from disk at %lld.",
               GetName(),idcur);
         break;
      }
      buffer  = header;
      bufread = header;
      frombuf(buffer, &nbytes);
      if (!nbytes) {
         Error("Recover","Address = %lld\tNbytes = %d\t=====E R R O R=======", idcur, nbytes);
         break;
      }
      if (nbytes < 0) {
         idcur -= nbytes;
         if (fWritable) new TFree(fFree,idcur,idcur-nbytes-1);
         Seek(idcur);
         continue;
      }
      Version_t versionkey;
      frombuf(buffer, &versionkey);
      frombuf(buffer, &objlen);
      frombuf(buffer, &datime);
      frombuf(buffer, &keylen);
      frombuf(buffer, &cycle);
      if (versionkey > 1000) {
         frombuf(buffer, &seekkey);
         frombuf(buffer, &seekpdir);
      } else {
         Int_t skey,sdir;
         frombuf(buffer, &skey);  seekkey  = (Long64_t)skey;
         frombuf(buffer, &sdir);  seekpdir = (Long64_t)sdir;
      }
      frombuf(buffer, &nwhc);
      char *classname = 0;
      if (nwhc <= 0 || nwhc > 100) break;
      classname = new char[nwhc+1];
      int i, nwhci = nwhc;
      for (i = 0;i < nwhc; i++) frombuf(buffer, &classname[i]);
      classname[nwhci] = '\0';
      TDatime::GetDateTime(datime, date, time);
      TClass *tclass = TClass::GetClass(classname);
      if (seekpdir == fSeekDir && tclass && !tclass->InheritsFrom(TFile::Class())
                               && strcmp(classname,"TBasket")) {
         key = new TKey(this);
         key->ReadKeyBuffer(bufread);
         if (!strcmp(key->GetName(),"StreamerInfo")) {
            fSeekInfo = seekkey;
            SafeDelete(fInfoCache);
            fNbytesInfo = nbytes;
         } else {
            AppendKey(key);
            nrecov++;
            SetBit(kRecovered);
            Info("Recover", "%s, recovered key %s:%s at address %lld",GetName(),key->GetClassName(),key->GetName(),idcur);
         }
      }
      delete [] classname;
      idcur += nbytes;
   }
   if (fWritable) {
      Long64_t max_file_size = Long64_t(kStartBigFile);
      if (max_file_size < fEND) max_file_size = fEND+1000000000;
      TFree *last = (TFree*)fFree->Last();
      if (last) {
         last->AddFree(fFree,fEND,max_file_size);
      } else {
         new TFree(fFree,fEND,max_file_size);
      }
      if (nrecov) Write();
   }
   return nrecov;
}

//______________________________________________________________________________
Int_t TFile::ReOpen(Option_t *mode)
{
   // Reopen a file with a different access mode, like from READ to
   // UPDATE or from NEW, CREATE, RECREATE, UPDATE to READ. Thus the
   // mode argument can be either "READ" or "UPDATE". The method returns
   // 0 in case the mode was successfully modified, 1 in case the mode
   // did not change (was already as requested or wrong input arguments)
   // and -1 in case of failure, in which case the file cannot be used
   // anymore. The current directory (gFile) is changed to this file.

   cd();

   TString opt = mode;
   opt.ToUpper();

   if (opt != "READ" && opt != "UPDATE") {
      Error("ReOpen", "mode must be either READ or UPDATE, not %s", opt.Data());
      return 1;
   }

   if (opt == fOption || (opt == "UPDATE" && fOption == "CREATE"))
      return 1;

   if (opt == "READ") {
      // switch to READ mode

      // flush data still in the pipeline and close the file
      if (IsOpen() && IsWritable()) {
         WriteStreamerInfo();

         // save directory key list and header
         Save();

         TFree *f1 = (TFree*)fFree->First();
         if (f1) {
            WriteFree();       // write free segments linked list
            WriteHeader();     // now write file header
         }

         FlushWriteCache();

         // delete free segments from free list
         if (fFree) {
            fFree->Delete();
            SafeDelete(fFree);
         }

         SysClose(fD);
         fD = -1;

         SetWritable(kFALSE);
      }

      // open in READ mode
      fOption = opt;    // set fOption before SysOpen() for TNetFile
#ifndef WIN32
      fD = SysOpen(fRealName, O_RDONLY, 0644);
#else
      fD = SysOpen(fRealName, O_RDONLY | O_BINARY, S_IREAD | S_IWRITE);
#endif
      if (fD == -1) {
         SysError("ReOpen", "file %s can not be opened in read mode", GetName());
         return -1;
      }
      SetWritable(kFALSE);

   } else {
      // switch to UPDATE mode

      // close readonly file
      if (IsOpen()) {
         SysClose(fD);
         fD = -1;
      }

      // open in UPDATE mode
      fOption = opt;    // set fOption before SysOpen() for TNetFile
#ifndef WIN32
      fD = SysOpen(fRealName, O_RDWR | O_CREAT, 0644);
#else
      fD = SysOpen(fRealName, O_RDWR | O_CREAT | O_BINARY, S_IREAD | S_IWRITE);
#endif
      if (fD == -1) {
         SysError("ReOpen", "file %s can not be opened in update mode", GetName());
         return -1;
      }
      SetWritable(kTRUE);

      fFree = new TList;
      if (fSeekFree > fBEGIN)
         ReadFree();
      else
         Warning("ReOpen","file %s probably not closed, cannot read free segments", GetName());
   }

   return 0;
}

//______________________________________________________________________________
void TFile::SetOffset(Long64_t offset, ERelativeTo pos)
{
   // Set position from where to start reading.

   switch (pos) {
      case kBeg:
         fOffset = offset + fArchiveOffset;
         break;
      case kCur:
         fOffset += offset;
         break;
      case kEnd:
         // this option is not used currently in the ROOT code
         if (fArchiveOffset)
            Error("SetOffset", "seeking from end in archive is not (yet) supported");
         fOffset = fEND + offset;  // is fEND really EOF or logical EOF?
         break;
   }
}

//______________________________________________________________________________
void TFile::Seek(Long64_t offset, ERelativeTo pos)
{
   // Seek to a specific position in the file. Pos it either kBeg, kCur or kEnd.

   int whence = 0;
   switch (pos) {
      case kBeg:
         whence = SEEK_SET;
         offset += fArchiveOffset;
         break;
      case kCur:
         whence = SEEK_CUR;
         break;
      case kEnd:
         whence = SEEK_END;
         // this option is not used currently in the ROOT code
         if (fArchiveOffset)
            Error("Seek", "seeking from end in archive is not (yet) supported");
         break;
   }
   Long64_t retpos;
   if ((retpos = SysSeek(fD, offset, whence)) < 0)
      SysError("Seek", "cannot seek to position %lld in file %s, retpos=%lld",
               offset, GetName(), retpos);

   // used by TFileCacheRead::ReadBuffer()
   fOffset = retpos;
}

//______________________________________________________________________________
void TFile::SetCompressionAlgorithm(Int_t algorithm)
{
   // See comments for function SetCompressionSettings
   if (algorithm < 0 || algorithm >= ROOT::kUndefinedCompressionAlgorithm) algorithm = 0;
   if (fCompress < 0) {
      // if the level is not defined yet use 1 as a default
      fCompress = 100 * algorithm + 1;
   } else {
      int level = fCompress % 100;
      fCompress = 100 * algorithm + level;
   }
}

//______________________________________________________________________________
void TFile::SetCompressionLevel(Int_t level)
{
   // See comments for function SetCompressionSettings
   if (level < 0) level = 0;
   if (level > 99) level = 99;
   if (fCompress < 0) {
      // if the algorithm is not defined yet use 0 as a default
      fCompress = level;
   } else {
      int algorithm = fCompress / 100;
      if (algorithm >= ROOT::kUndefinedCompressionAlgorithm) algorithm = 0;
      fCompress = 100 * algorithm + level;
   }
}

//______________________________________________________________________________
void TFile::SetCompressionSettings(Int_t settings)
{
   // Used to specify the compression level and algorithm:
   //  settings = 100 * algorithm + level
   //
   //  level = 0, objects written to this file will not be compressed.
   //  level = 1, minimal compression level but fast.
   //  ....
   //  level = 9, maximal compression level but slower and might use more memory.
   // (For the currently supported algorithms, the maximum level is 9)
   // If compress is negative it indicates the compression level is not set yet.
   //
   // The enumeration ROOT::ECompressionAlgorithm associates each
   // algorithm with a number. There is a utility function to help
   // to set the value of the argument. For example,
   //   ROOT::CompressionSettings(ROOT::kLZMA, 1)
   // will build an integer which will set the compression to use
   // the LZMA algorithm and compression level 1.  These are defined
   // in the header file Compression.h.
   //
   // Note that the compression settings may be changed at any time.
   // The new compression settings will only apply to branches created
   // or attached after the setting is changed and other objects written
   // after the setting is changed.
   fCompress = settings;
}

//______________________________________________________________________________
void TFile::SetCacheRead(TFileCacheRead *cache, TObject* tree, ECacheAction action)
{
   // Set a pointer to the read cache.
   // NOTE:  This relinquish ownership of the previous cache, so if you do not
   // already have a pointer to the previous cache (and there was a previous
   // cache), you ought to retrieve (and delete it if needed) using:
   //    TFileCacheRead *older = myfile->GetCacheRead();
   //
   // NOTE: the action specifies how to behave when detaching a cache from the
   // the TFile.  If set to (default) kDisconnect, the contents of the cache
   // will be flushed when it is removed from the file, and it will disconnect
   // the cache object from the file.  In almost all cases, this is what you want.
   // If you want to disconnect the cache temporarily from this tree and re-attach
   // later to the same fil, you can set action to kDoNotDisconnect.  This will allow
   // things like prefetching to continue in the background while it is no longer the
   // default cache for the TTree.  Except for a few expert use cases, kDisconnect is
   // likely the correct setting.
   //
   // WARNING: if action=kDoNotDisconnect, you MUST delete the cache before TFile.
   //

   if (tree) {
      if (cache) fCacheReadMap->Add(tree, cache);
      else {
         // The only addition to fCacheReadMap is via an interface that takes
         // a TFileCacheRead* so the C-cast is safe.
         TFileCacheRead* tpf = (TFileCacheRead *)fCacheReadMap->GetValue(tree);
         fCacheReadMap->RemoveEntry(tree);
         if (tpf && (tpf->GetFile() == this) && (action != kDoNotDisconnect)) tpf->SetFile(0, action);
      }
   }
   if (cache) cache->SetFile(this, action);
   else if (!tree && fCacheRead && (action != kDoNotDisconnect)) fCacheRead->SetFile(0, action);
   // For backward compatibility the last Cache set is the default cache.
   fCacheRead = cache;
}

//______________________________________________________________________________
void TFile::SetCacheWrite(TFileCacheWrite *cache)
{
   // Set a pointer to the write cache.
   // If file is null the existing write cache is deleted.

   if (!cache && fCacheWrite) delete fCacheWrite;
   fCacheWrite = cache;
}

//______________________________________________________________________________
Int_t TFile::Sizeof() const
{
   // Return the size in bytes of the file header.

   return 0;
}

//_______________________________________________________________________
void TFile::Streamer(TBuffer &b)
{
   // Stream a TFile object.

   if (b.IsReading()) {
      b.ReadVersion();  //Version_t v = b.ReadVersion();
   } else {
      b.WriteVersion(TFile::IsA());
   }
}

//_______________________________________________________________________
void TFile::SumBuffer(Int_t bufsize)
{
   // Increment statistics for buffer sizes of objects in this file.

   fWritten++;
   fSumBuffer  += bufsize;
   fSum2Buffer += bufsize*bufsize;
}

//______________________________________________________________________________
Int_t TFile::Write(const char *, Int_t opt, Int_t bufsiz)
{
   // Write memory objects to this file.
   // Loop on all objects in memory (including subdirectories).
   // A new key is created in the KEYS linked list for each object.
   // The list of keys is then saved on the file (via WriteKeys)
   // as a single data record.
   // For values of opt see TObject::Write().
   // The directory header info is rewritten on the directory header record.
   // The linked list of FREE segments is written.
   // The file header is written (bytes 1->fBEGIN).

   if (!IsWritable()) {
      if (!TestBit(kWriteError)) {
         // Do not print the warning if we already had a SysError.
         Warning("Write", "file %s not opened in write mode", GetName());
      }
      return 0;
   }

   if (gDebug) {
      if (!GetTitle() || strlen(GetTitle()) == 0)
         Info("Write", "writing name = %s", GetName());
      else
         Info("Write", "writing name = %s title = %s", GetName(), GetTitle());
   }

   fMustFlush = kFALSE;
   Int_t nbytes = TDirectoryFile::Write(0, opt, bufsiz); // Write directory tree
   WriteStreamerInfo();
   WriteFree();                       // Write free segments linked list
   WriteHeader();                     // Now write file header
   fMustFlush = kTRUE;

   return nbytes;
}

//______________________________________________________________________________
Int_t TFile::Write(const char *n, Int_t opt, Int_t bufsize) const
{
   // One can not save a const TDirectory object.

   Error("Write const","A const TFile object should not be saved. We try to proceed anyway.");
   return const_cast<TFile*>(this)->Write(n, opt, bufsize);
}

//______________________________________________________________________________
Bool_t TFile::WriteBuffer(const char *buf, Int_t len)
{
   // Write a buffer to the file. This is the basic low level write operation.
   // Returns kTRUE in case of failure.

   if (IsOpen() && fWritable) {

      Int_t st;
      if ((st = WriteBufferViaCache(buf, len))) {
         if (st == 2)
            return kTRUE;
         return kFALSE;
      }

      ssize_t siz;
      gSystem->IgnoreInterrupt();
      while ((siz = SysWrite(fD, buf, len)) < 0 && GetErrno() == EINTR)
         ResetErrno();
      gSystem->IgnoreInterrupt(kFALSE);
      if (siz < 0) {
         // Write the system error only once for this file
         SetBit(kWriteError); SetWritable(kFALSE);
         SysError("WriteBuffer", "error writing to file %s (%ld)", GetName(), (Long_t)siz);
         return kTRUE;
      }
      if (siz != len) {
         SetBit(kWriteError);
         Error("WriteBuffer", "error writing all requested bytes to file %s, wrote %ld of %d",
               GetName(), (Long_t)siz, len);
         return kTRUE;
      }
      fBytesWrite  += siz;
      fgBytesWrite += siz;

      if (gMonitoringWriter)
         gMonitoringWriter->SendFileWriteProgress(this);

      return kFALSE;
   }
   return kTRUE;
}

//______________________________________________________________________________
Int_t TFile::WriteBufferViaCache(const char *buf, Int_t len)
{
   // Write buffer via cache. Returns 0 if cache is not active, 1 in case
   // write via cache was successful, 2 in case write via cache failed.

   if (!fCacheWrite) return 0;

   Int_t st;
   Long64_t off = GetRelOffset();
   if ((st = fCacheWrite->WriteBuffer(buf, off, len)) < 0) {
      SetBit(kWriteError);
      Error("WriteBuffer", "error writing to cache");
      return 2;
   }
   if (st > 0) {
      // fOffset might have been changed via TFileCacheWrite::WriteBuffer(), reset it
      Seek(off + len);
      return 1;
   }
   return 0;
}

//______________________________________________________________________________
void TFile::WriteFree()
{
   // Write FREE linked list on the file.
   // The linked list of FREE segments (fFree) is written as a single data
   // record.

   //*-* Delete old record if it exists
   if (fSeekFree != 0){
      MakeFree(fSeekFree, fSeekFree + fNbytesFree -1);
   }

   Int_t nbytes = 0;
   TFree *afree;
   TIter next (fFree);
   while ((afree = (TFree*) next())) {
      nbytes += afree->Sizeof();
   }
   if (!nbytes) return;

   TKey *key    = new TKey(fName,fTitle,IsA(),nbytes,this);
   if (key->GetSeekKey() == 0) {
      delete key;
      return;
   }
   char *buffer = key->GetBuffer();
   char *start = buffer;

   next.Reset();
   while ((afree = (TFree*) next())) {
      afree->FillBuffer(buffer);
   }
   if ( (buffer-start)!=nbytes ) {
      // Most likely one of the 'free' segment was used to store this
      // TKey, so we had one less TFree to store than we planned.
      memset(buffer,0,nbytes-(buffer-start));
   }
   fNbytesFree = key->GetNbytes();
   fSeekFree   = key->GetSeekKey();
   key->WriteFile();
   delete key;
}

//______________________________________________________________________________
void TFile::WriteHeader()
{
   // Write File Header.

   SafeDelete(fInfoCache);
   TFree *lastfree = (TFree*)fFree->Last();
   if (lastfree) fEND  = lastfree->GetFirst();
   const char *root = "root";
   char *psave  = new char[fBEGIN];
   char *buffer = psave;
   Int_t nfree  = fFree->GetSize();
   memcpy(buffer, root, 4); buffer += 4;
   Int_t version = fVersion;
   if (version <1000000 && fEND > kStartBigFile) {version += 1000000; fUnits = 8;}
   tobuf(buffer, version);
   tobuf(buffer, (Int_t)fBEGIN);
   if (version < 1000000) {
      tobuf(buffer, (Int_t)fEND);
      tobuf(buffer, (Int_t)fSeekFree);
      tobuf(buffer, fNbytesFree);
      tobuf(buffer, nfree);
      tobuf(buffer, fNbytesName);
      tobuf(buffer, fUnits);
      tobuf(buffer, fCompress);
      tobuf(buffer, (Int_t)fSeekInfo);
      tobuf(buffer, fNbytesInfo);
   } else {
      tobuf(buffer, fEND);
      tobuf(buffer, fSeekFree);
      tobuf(buffer, fNbytesFree);
      tobuf(buffer, nfree);
      tobuf(buffer, fNbytesName);
      tobuf(buffer, fUnits);
      tobuf(buffer, fCompress);
      tobuf(buffer, fSeekInfo);
      tobuf(buffer, fNbytesInfo);
   }
   fUUID.FillBuffer(buffer);
   Int_t nbytes  = buffer - psave;
   Seek(0);
   WriteBuffer(psave, nbytes);
   Flush(); // Intentionally not conditional on fMustFlush, this is the 'obligatory' flush.
   delete [] psave;
}

//______________________________________________________________________________
void TFile::MakeProject(const char *dirname, const char * /*classes*/,
                        Option_t *option)
{
   // Generate code in directory dirname for all classes specified in
   // argument classes If classes = "*" (default and currently the
   // only supported value), the function generates an include file
   // for each class in the StreamerInfo list for which a TClass
   // object does not exist.
   //
   // The code generated includes:
   //    dirnameProjectHeaders.h  // contains one #include statement per generated header file
   //    dirnameProjectSource.cxx // contains all the constructors and destructors implementation.
   // and one header per class that is not nested inside another class.
   // The header file name is the fully qualified name of the class after all the special characters
   // "<>,:" are replaced by underscored.  For example for std::pair<edm::Vertex,int> the file name is
   // pair_edm__Vertex_int_.h
   //
   // In the generated classes, map, multimap when the first template parameter is a class
   // are replaced by a vector of pair. set and multiset when the tempalte parameter
   // is a class are replaced by a vector. This is required since we do not have the
   // code needed to order and/or compare the object of the classes.
   //
   // If option = "new" (default) a new directory dirname is created.
   //                   If dirname already exist, an error message is printed
   //                   and the function returns.
   // If option = "recreate", then;
   //                   if dirname does not exist, it is created (like in "new")
   //                   if dirname already exist, all existing files in dirname
   //                   are deleted before creating the new files.
   // If option = "update", then new classes are added to the existing directory.
   //                   Existing classes with the same name are replaced by the
   //                   new definition. If the directory dirname doest not exist,
   //                   same effect as "new".
   // If option = "genreflex", then use genreflex rather than rootcint to generate
   //                   the dictionary.
   // If option = "par", create a PAR file with the minimal set of code needed to read the content
   //                   of the ROOT file. The name of the PAR file is basename(dirname), with extension
   //                   '.par' enforced; the PAR file will be created at dirname(dirname) .
   // If, in addition to one of the 3 above options, the option "+" is specified,
   // the function will generate:
   //   - a script called MAKEP to build the shared lib
   //   - a dirnameLinkDef.h file
   //   - rootcint will be run to generate a dirnameProjectDict.cxx file
   //   - dirnameProjectDict.cxx will be compiled with the current options in compiledata.h
   //   - a shared lib dirname.so will be created.
   // If the option "++" is specified, the generated shared lib is dynamically
   // linked with the current executable module.
   // If the option "+" and "nocompile" are specified, the utility files are generated
   // as in the option "+" but they are not executed.
   // Example:
   //  file.MakeProject("demo","*","recreate++");
   //  - creates a new directory demo unless it already exist
   //  - clear the previous directory content
   //  - generate the xxx.h files for all classes xxx found in this file
   //    and not yet known to the CINT dictionary.
   //  - creates the build script MAKEP
   //  - creates a LinkDef.h file
   //  - runs rootcint generating demoProjectDict.cxx
   //  - compiles demoProjectDict.cxx into demoProjectDict.o
   //  - generates a shared lib demo.so
   //  - dynamically links the shared lib demo.so to the executable
   //  If only the option "+" had been specified, one can still link the
   //  shared lib to the current executable module with:
   //     gSystem->load("demo/demo.so");
   //
   // The following feature is not yet enabled:
   // One can restrict the list of classes to be generated by using expressions like:
   //   classes = "Ali*" generate code only for classes starting with Ali
   //   classes = "myClass" generate code for class MyClass only.
   //

   TString opt = option;
   opt.ToLower();
   Bool_t makepar = kFALSE;
   TString parname, pardir;
   if (opt.Contains("par")) {
      // Create a PAR file
      parname = gSystem->BaseName(dirname);
      if (parname.EndsWith(".par")) parname.ReplaceAll(".par","");
      pardir = gSystem->DirName(dirname);
      // Cleanup or prepare the dirs
      TString path, filepath;
      void *dir = gSystem->OpenDirectory(pardir);
      if (dir) {
         path.Form("%s/%s", pardir.Data(), parname.Data());
         void *dirp = gSystem->OpenDirectory(path);
         if (dirp) {
            path += "/PROOF-INF";
            void *dirinf = gSystem->OpenDirectory(path);
            const char *afile = 0;
            if (dirinf) {
               while ((afile = gSystem->GetDirEntry(dirinf))) {
                  if (strcmp(afile,".") == 0) continue;
                  if (strcmp(afile,"..") == 0) continue;
                  filepath.Form("%s/%s", path.Data(), afile);
                  if (gSystem->Unlink(filepath))
                     Warning("MakeProject", "1: problems unlinking '%s' ('%s', '%s')", filepath.Data(), path.Data(), afile);
               }
               gSystem->FreeDirectory(dirinf);
            }
            gSystem->Unlink(path);
            path.Form("%s/%s", pardir.Data(), parname.Data());
            while ((afile = gSystem->GetDirEntry(dirp))) {
               if (strcmp(afile,".") == 0) continue;
               if (strcmp(afile,"..") == 0) continue;
               filepath.Form("%s/%s", path.Data(), afile);
               if (gSystem->Unlink(filepath))
                  Warning("MakeProject", "2: problems unlinking '%s' ('%s', '%s')", filepath.Data(), path.Data(), afile);
            }
            gSystem->FreeDirectory(dirp);
            if (gSystem->Unlink(path))
               Warning("MakeProject", "problems unlinking '%s'", path.Data());
         }
      }
      // Make sure that the relevant dirs exists: this is mandatory, so we fail if unsuccessful
      path.Form("%s/%s/PROOF-INF", pardir.Data(), parname.Data());
      if (gSystem->mkdir(path, kTRUE)) {
         Error("MakeProject", "problems creating '%s'", path.Data());
         return;
      }
      makepar = kTRUE;

   } else {
      void *dir = gSystem->OpenDirectory(dirname);
      TString dirpath;

      if (opt.Contains("update")) {
         // check that directory exist, if not create it
         if (dir == 0) {
            gSystem->mkdir(dirname);
         }

      } else if (opt.Contains("recreate")) {
         // check that directory exist, if not create it
         if (dir == 0) {
            if (gSystem->mkdir(dirname) < 0) {
               Error("MakeProject","cannot create directory '%s'",dirname);
               return;
            }
         }
         // clear directory
         while (dir) {
            const char *afile = gSystem->GetDirEntry(dir);
            if (afile == 0) break;
            if (strcmp(afile,".") == 0) continue;
            if (strcmp(afile,"..") == 0) continue;
            dirpath.Form("%s/%s",dirname,afile);
            gSystem->Unlink(dirpath);
         }

      } else {
         // new is assumed
         // if directory already exist, print error message and return
         if (dir) {
            Error("MakeProject","cannot create directory %s, already existing",dirname);
            gSystem->FreeDirectory(dir);
            return;
         }
         if (gSystem->mkdir(dirname) < 0) {
            Error("MakeProject","cannot create directory '%s'",dirname);
            return;
         }
      }
      if (dir) {
         gSystem->FreeDirectory(dir);
      }
   }
   Bool_t genreflex = opt.Contains("genreflex");

   // we are now ready to generate the classes
   // loop on all TStreamerInfo
   TList *filelist = (TList*)GetStreamerInfoCache();
   if (filelist) filelist = (TList*)filelist->Clone();
   if (filelist == 0) {
      Error("MakeProject","file %s has no StreamerInfo", GetName());
      return;
   }

   TString clean_dirname(dirname);
   if (makepar) clean_dirname.Form("%s/%s", pardir.Data(), parname.Data());
   if (clean_dirname[clean_dirname.Length()-1]=='/') {
      clean_dirname.Remove(clean_dirname.Length()-1);
   } else if (clean_dirname[clean_dirname.Length()-1]=='\\') {
      clean_dirname.Remove(clean_dirname.Length()-1);
      if (clean_dirname[clean_dirname.Length()-1]=='\\') {
         clean_dirname.Remove(clean_dirname.Length()-1);
      }
   }
   TString subdirname( gSystem->BaseName(clean_dirname) );
   if (makepar) subdirname = parname;
   if (subdirname == "") {
      Error("MakeProject","Directory name must not be empty.");
      return;
   }

   // Start the source file
   TString spath; spath.Form("%s/%sProjectSource.cxx",clean_dirname.Data(),subdirname.Data());
   FILE *sfp = fopen(spath.Data(),"w");
   if (sfp ==0) {
      Error("MakeProject","Unable to create the source file %s.",spath.Data());
      return;
   }
   fprintf(sfp, "namespace std {}\nusing namespace std;\n");
   fprintf(sfp, "#include \"%sProjectHeaders.h\"\n\n",subdirname.Data() );
   if (!genreflex) fprintf(sfp, "#include \"%sLinkDef.h\"\n\n",subdirname.Data() );
   fprintf(sfp, "#include \"%sProjectDict.cxx\"\n\n",subdirname.Data() );
   fprintf(sfp, "struct DeleteObjectFunctor {\n");
   fprintf(sfp, "   template <typename T>\n");
   fprintf(sfp, "   void operator()(const T *ptr) const {\n");
   fprintf(sfp, "      delete ptr;\n");
   fprintf(sfp, "   }\n");
   fprintf(sfp, "   template <typename T, typename Q>\n");
   fprintf(sfp, "   void operator()(const std::pair<T,Q> &) const {\n");
   fprintf(sfp, "      // Do nothing\n");
   fprintf(sfp, "   }\n");
   fprintf(sfp, "   template <typename T, typename Q>\n");
   fprintf(sfp, "   void operator()(const std::pair<T,Q*> &ptr) const {\n");
   fprintf(sfp, "      delete ptr.second;\n");
   fprintf(sfp, "   }\n");
   fprintf(sfp, "   template <typename T, typename Q>\n");
   fprintf(sfp, "   void operator()(const std::pair<T*,Q> &ptr) const {\n");
   fprintf(sfp, "      delete ptr.first;\n");
   fprintf(sfp, "   }\n");
   fprintf(sfp, "   template <typename T, typename Q>\n");
   fprintf(sfp, "   void operator()(const std::pair<T*,Q*> &ptr) const {\n");
   fprintf(sfp, "      delete ptr.first;\n");
   fprintf(sfp, "      delete ptr.second;\n");
   fprintf(sfp, "   }\n");
   fprintf(sfp, "};\n\n");
   fclose( sfp );

   // loop on all TStreamerInfo classes to check for empty classes
   // and enums listed either as data member or template parameters,
   // and filter out 'duplicates' classes/streamerInfos.
   TStreamerInfo *info;
   TIter flnext(filelist);
   TList extrainfos;
   TList *list = new TList();
   while ((info = (TStreamerInfo*)flnext())) {
      if (info->IsA() != TStreamerInfo::Class()) {
         continue;
      }
      if (strstr(info->GetName(),"@@")) {
         // Skip schema evolution support streamerInfo
         continue;
      }
      TClass *cl = TClass::GetClass(info->GetName());
      if (cl) {
         if (cl->HasInterpreterInfo()) continue; // skip known classes
      }
      // Find and use the proper rules for the TStreamerInfos.
      TMakeProject::GenerateMissingStreamerInfos( &extrainfos, info->GetName() );
      TIter enext( info->GetElements() );
      TStreamerElement *el;
      const ROOT::TSchemaMatch* rules = 0;
      if (cl && cl->GetSchemaRules()) {
         rules = cl->GetSchemaRules()->FindRules(cl->GetName(), info->GetClassVersion());
      }
      while( (el=(TStreamerElement*)enext()) ) {
         if (rules) {
            for(Int_t art = 0; art < rules->GetEntries(); ++art) {
               ROOT::TSchemaRule *rule = (ROOT::TSchemaRule*)rules->At(art);
               if( rule->IsRenameRule() || rule->IsAliasRule() )
                  continue;
               // Check whether this is an 'attribute' rule.
               if ( rule->HasTarget( el->GetName()) && rule->GetAttributes()[0] != 0 ) {
                  TString attr( rule->GetAttributes() );
                  attr.ToLower();
                  if (attr.Contains("owner")) {
                     if (attr.Contains("notowner")) {
                        el->SetBit(TStreamerElement::kDoNotDelete);
                     } else {
                        el->ResetBit(TStreamerElement::kDoNotDelete);
                     }
                  }
               }
            }
         }
         TMakeProject::GenerateMissingStreamerInfos(&extrainfos, el);
      }
      delete rules;
      TVirtualStreamerInfo *alternate = (TVirtualStreamerInfo*)list->FindObject(info->GetName());
      if (alternate) {
         if ((info->GetClass() && info->GetClassVersion() == info->GetClass()->GetClassVersion())
             || (info->GetClassVersion() > alternate->GetClassVersion()) ) {
            list->AddAfter(alternate, info);
            list->Remove(alternate);
         } // otherwise ingnore this info as not being the official one.
      } else {
         list->Add(info);
      }
   }
   // Now transfer the new StreamerInfo onto the main list and
   // to the owning list.
   TIter nextextra(&extrainfos);
   while ((info = (TStreamerInfo*)nextextra())) {
      list->Add(info);
      filelist->Add(info);
   }

   // loop on all TStreamerInfo classes
   TIter next(list);
   Int_t ngener = 0;
   while ((info = (TStreamerInfo*)next())) {
      if (info->IsA() != TStreamerInfo::Class()) {
         continue;
      }
      if (info->GetClassVersion()==-4) continue; // Skip outer level namespace
      TIter subnext(list);
      TStreamerInfo *subinfo;
      TList subClasses;
      Int_t len = strlen(info->GetName());
      while ((subinfo = (TStreamerInfo*)subnext())) {
         if (subinfo->IsA() != TStreamerInfo::Class()) {
            continue;
         }
         if (strncmp(info->GetName(),subinfo->GetName(),len)==0) {
            // The 'sub' StreamerInfo start with the main StreamerInfo name,
            // it subinfo is likely to be a nested class.
            const Int_t sublen = strlen(subinfo->GetName());
            if ( (sublen > len) && subinfo->GetName()[len+1]==':'
               && !subClasses.FindObject(subinfo->GetName()) /* We need to insure uniqueness */)
            {
               subClasses.Add(subinfo);
            }
         }
      }
      ngener += info->GenerateHeaderFile(clean_dirname.Data(),&subClasses,&extrainfos);
      subClasses.Clear("nodelete");
   }
   TString path;
   path.Form("%s/%sProjectHeaders.h",clean_dirname.Data(),subdirname.Data());
   FILE *allfp = fopen(path,"a");
   if (!allfp) {
      Error("MakeProject","Cannot open output file:%s\n",path.Data());
   } else {
      fprintf(allfp,"#include \"%sProjectInstances.h\"\n", subdirname.Data());
      fclose(allfp);
   }

   printf("MakeProject has generated %d classes in %s\n",ngener,clean_dirname.Data());

   // generate the shared lib
   if (!opt.Contains("+") && !makepar) {
      delete list;
      filelist->Delete();
      delete filelist;
      return;
   }

   // Makefiles files
   FILE *fpMAKE = 0;
   if (!makepar) {
      // Create the MAKEP file by looping on all *.h files
      // delete MAKEP if it already exists
#ifdef WIN32
      path.Form("%s/makep.cmd",clean_dirname.Data());
#else
      path.Form("%s/MAKEP",clean_dirname.Data());
#endif
#ifdef R__WINGCC
      fpMAKE = fopen(path,"wb");
#else
      fpMAKE = fopen(path,"w");
#endif
      if (!fpMAKE) {
         Error("MakeProject", "cannot open file %s", path.Data());
         delete list;
         filelist->Delete();
         delete filelist;
         return;
      }
   }

   // Add rootcint/genreflex statement generating ProjectDict.cxx
   FILE *ifp = 0;
   path.Form("%s/%sProjectInstances.h",clean_dirname.Data(),subdirname.Data());
#ifdef R__WINGCC
   ifp = fopen(path,"wb");
#else
   ifp = fopen(path,"w");
#endif
   if (!ifp) {
      Error("MakeProject", "cannot open path file %s", path.Data());
      delete list;
      filelist->Delete();
      delete filelist;
      fclose(fpMAKE);
      return;
   }

   if (!makepar) {
      if (genreflex) {
         fprintf(fpMAKE,"genreflex %sProjectHeaders.h -o %sProjectDict.cxx --comments --iocomments %s ",subdirname.Data(),subdirname.Data(),gSystem->GetIncludePath());
         path.Form("%s/%sSelection.xml",clean_dirname.Data(),subdirname.Data());
      } else {
         fprintf(fpMAKE,"rootcint -f %sProjectDict.cxx -c %s ",subdirname.Data(),gSystem->GetIncludePath());
         path.Form("%s/%sLinkDef.h",clean_dirname.Data(),subdirname.Data());
      }
   } else {
      path.Form("%s/%sLinkDef.h",clean_dirname.Data(),subdirname.Data());
   }

   // Create the LinkDef.h or xml selection file by looping on all *.h files
   // replace any existing file.
#ifdef R__WINGCC
   FILE *fp = fopen(path,"wb");
#else
   FILE *fp = fopen(path,"w");
#endif
   if (!fp) {
      Error("MakeProject", "cannot open path file %s", path.Data());
      delete list;
      filelist->Delete();
      delete filelist;
      fclose(fpMAKE);
      fclose(ifp);
      return;
   }
   if (genreflex) {
      fprintf(fp,"<lcgdict>\n");
      fprintf(fp,"\n");
   } else {
      fprintf(fp,"#ifdef __CINT__\n");
      fprintf(fp,"\n");
   }

   TString tmp;
   TString instances;
   TString selections;
   next.Reset();
   while ((info = (TStreamerInfo*)next())) {
      if (info->IsA() != TStreamerInfo::Class()) {
         continue;
      }
      TClass *cl = TClass::GetClass(info->GetName());
      if (cl) {
         if (cl->HasInterpreterInfo()) continue; // skip known classes
         const ROOT::TSchemaMatch* rules = 0;
         if (cl->GetSchemaRules()) {
            rules = cl->GetSchemaRules()->FindRules(cl->GetName(), info->GetClassVersion());
            TString strrule;
            if (rules) {
               for(Int_t art = 0; art < rules->GetEntries(); ++art) {
                  ROOT::TSchemaRule *rule = (ROOT::TSchemaRule*)rules->At(art);
                  strrule.Clear();
                  if (genreflex) {
                     rule->AsString(strrule,"x");
                     strrule.Append("\n");
                     if ( selections.Index(strrule) == kNPOS ) {
                        selections.Append(strrule);
                     }
                  } else {
                     rule->AsString(strrule);
                     if (strncmp(strrule.Data(),"type=",5)==0) {
                        strrule.Remove(0,5);
                     }
                     fprintf(fp,"#pragma %s;\n",strrule.Data());
                  }
               }
            }
            delete rules;
         }

      }
      if (TClassEdit::IsSTLCont(info->GetName())) {
         std::vector<std::string> inside;
         int nestedLoc;
         TClassEdit::GetSplit( info->GetName(), inside, nestedLoc, TClassEdit::kLong64 );
         Int_t stlkind =  TClassEdit::STLKind(inside[0].c_str());
         TClass *key = TClass::GetClass(inside[1].c_str());
         if (key) {
            TString what;
            switch ( stlkind )  {
            case ROOT::kSTLmap:
            case ROOT::kSTLmultimap:
               if (TClass::GetClass(inside[1].c_str())) {
                  what = "std::pair<";
                  what += TMakeProject::UpdateAssociativeToVector( inside[1].c_str() );
                  what += ",";
                  what += TMakeProject::UpdateAssociativeToVector( inside[2].c_str() );
                  if (what[what.Length()-1]=='>') {
                     what += " >";
                  } else {
                     what += ">";
                  }
                  if (genreflex) {
                     tmp.Form("<class name=\"%s\" />\n",what.Data());
                     if ( selections.Index(tmp) == kNPOS ) {
                        selections.Append(tmp);
                     }
                     tmp.Form("template class %s;\n",what.Data());
                     if ( instances.Index(tmp) == kNPOS ) {
                        instances.Append(tmp);
                     }
                  } else {
                     what.ReplaceAll("std::","");
                     TClass *paircl = TClass::GetClass(what.Data());
                     if (paircl == 0 || !paircl->HasInterpreterInfo()) {
                        fprintf(fp,"#pragma link C++ class %s+;\n",what.Data());
                     }
                  }
                  break;
               }
            default:
               if (strncmp(key->GetName(),"pair<",strlen("pair<"))==0) {
                  if (genreflex) {
                     tmp.Form("<class name=\"%s\" />\n",key->GetName());
                     if ( selections.Index(tmp) == kNPOS ) {
                        selections.Append(tmp);
                     }
                     tmp.Form("template class %s;\n",key->GetName());
                     if ( instances.Index(tmp) == kNPOS ) {
                        instances.Append(tmp);
                     }
                  } else {
                     what.ReplaceAll("std::","");
                     fprintf(fp,"#pragma link C++ class %s+;\n",key->GetName());
                  }
               }
               break;
            }
         }
         continue;
      }
      {
         TString what(TMakeProject::UpdateAssociativeToVector(info->GetName()).Data());
         if (genreflex) {
            tmp.Form("<class name=\"%s\" />\n",what.Data());
            if ( selections.Index(tmp) == kNPOS ) {
               selections.Append(tmp);
            }
            if (what[what.Length()-1] == '>') {
               tmp.Form("template class %s;\n",what.Data());
               if ( instances.Index(tmp) == kNPOS ) {
                  instances.Append(tmp);
               }
            }
         } else {
            what.ReplaceAll("std::","");
            fprintf(fp,"#pragma link C++ class %s+;\n",what.Data());
         }
      }
      if (genreflex) {
         // Also request the dictionary for the STL container used as members ...
         TIter eliter( info->GetElements() );
         TStreamerElement *element;
         while( (element = (TStreamerElement*)eliter() ) ) {
            if (element->GetClass() && !element->GetClass()->IsLoaded() && element->GetClass()->GetCollectionProxy()) {
               TString what( TMakeProject::UpdateAssociativeToVector(element->GetClass()->GetName()) );
               tmp.Form("<class name=\"%s\" />\n",what.Data());
               if ( selections.Index(tmp) == kNPOS ) {
                  selections.Append(tmp);
               }
               tmp.Form("template class %s;\n",what.Data());
               if ( instances.Index(tmp) == kNPOS ) {
                  instances.Append(tmp);
               }
            }
         }
      }
   }
   if (genreflex) {
      fprintf(ifp,"#ifndef PROJECT_INSTANCES_H\n");
      fprintf(ifp,"#define PROJECT_INSTANCES_H\n");
      fprintf(ifp,"%s",instances.Data());
      fprintf(ifp,"#endif\n");
      fprintf(fp,"%s",selections.Data());
      fprintf(fp,"</lcgdict>\n");
   } else {
      fprintf(fp,"#endif\n");
   }
   fclose(fp);
   fclose(ifp);

   if (!makepar) {
      // add compilation line
      TString sdirname(subdirname);

      TString cmd = gSystem->GetMakeSharedLib();
      TString sources = TString::Format("%sProjectSource.cxx ", sdirname.Data());
      cmd.ReplaceAll("$SourceFiles",sources.Data());
      TString object = TString::Format("%sProjectSource.", sdirname.Data());
      object.Append( gSystem->GetObjExt() );
      cmd.ReplaceAll("$ObjectFiles", object.Data());
      cmd.ReplaceAll("$IncludePath",TString(gSystem->GetIncludePath()) + " -I" + clean_dirname.Data());
      cmd.ReplaceAll("$SharedLib",sdirname+"."+gSystem->GetSoExt());
      cmd.ReplaceAll("$LinkedLibs",gSystem->GetLibraries("","SDL"));
      cmd.ReplaceAll("$LibName",sdirname);
      cmd.ReplaceAll("$BuildDir",".");
      TString sOpt;
      TString rootbuild = ROOTBUILD;
      if (rootbuild.Index("debug",0,TString::kIgnoreCase)==kNPOS) {
         sOpt = gSystem->GetFlagsOpt();
      } else {
         sOpt = gSystem->GetFlagsDebug();
      }
      cmd.ReplaceAll("$Opt", sOpt);

      if (genreflex) {
         fprintf(fpMAKE,"-s %sSelection.xml \n",subdirname.Data());
      } else {
         fprintf(fpMAKE,"%sProjectHeaders.h ",subdirname.Data());
         fprintf(fpMAKE,"%sLinkDef.h \n",subdirname.Data());
      }

      fprintf(fpMAKE,"%s\n",cmd.Data());

      printf("%s/MAKEP file has been generated\n", clean_dirname.Data());

      fclose(fpMAKE);

   } else {

      // Create the Makefile
      TString filemake = TString::Format("%s/Makefile", clean_dirname.Data());
      if (MakeProjectParMake(parname, filemake.Data()) != 0) {
         Error("MakeProject", "problems creating PAR make file '%s'", filemake.Data());
         delete list;
         filelist->Delete();
         delete filelist;
         return;
      }
      // Get Makefile.arch
#ifdef ROOTETCDIR
      TString mkarchsrc = TString::Format("%s/Makefile.arch", ROOTETCDIR);
#else
      TString mkarchsrc("$(ROOTSYS)/etc/Makefile.arch");
#endif
      if (gSystem->ExpandPathName(mkarchsrc))
         Warning("MakeProject", "problems expanding '%s'", mkarchsrc.Data());
      TString mkarchdst = TString::Format("%s/Makefile.arch", clean_dirname.Data());
      if (gSystem->CopyFile(mkarchsrc.Data(), mkarchdst.Data(), kTRUE) != 0) {
         Error("MakeProject", "problems retrieving '%s' to '%s'", mkarchsrc.Data(), mkarchdst.Data());
         delete list;
         filelist->Delete();
         delete filelist;
         return;
      }
      // Create the Makefile
      TString proofinf = TString::Format("%s/PROOF-INF", clean_dirname.Data());
      if (MakeProjectParProofInf(parname, proofinf.Data()) != 0) {
         Error("MakeProject", "problems creating BUILD.sh and/or SETUP.C under '%s'", proofinf.Data());
         delete list;
         filelist->Delete();
         delete filelist;
         return;
      }

      // Make sure BUILD.sh is executable and create SETUP.C
      TString cmod = TString::Format("chmod +x %s/PROOF-INF/BUILD.sh", clean_dirname.Data());
#ifndef WIN32
      gSystem->Exec(cmod.Data());
#else
      // not really needed for Windows but it would work both both Unix and NT
      chmod(cmod.Data(), 00700);
#endif
      Printf("Files Makefile, Makefile.arch, PROOF-INF/BUILD.sh and"
             " PROOF-INF/SETUP.C have been generated under '%s'", clean_dirname.Data());

      // Generate the PAR file, if not Windows
#ifndef WIN32
      TString curdir = gSystem->WorkingDirectory();
      if (gSystem->ChangeDirectory(pardir)) {
         TString cmd = TString::Format("tar czvf %s.par %s", parname.Data(), parname.Data());
         gSystem->Exec(cmd.Data());
         if (gSystem->ChangeDirectory(curdir)) {
            Info("MakeProject", "PAR file %s.par generated", clean_dirname.Data());
         } else {
            Warning("MakeProject", "problems changing directory back to '%s'", curdir.Data());
         }
      } else {
         Error("MakeProject", "problems changing directory to '%s' - skipping PAR file generation", pardir.Data());
      }
#else
      Warning("MakeProject", "on Windows systems the PAR file cannot be generated out of the package directory!");
#endif
   }


   if (!makepar && !opt.Contains("nocompilation")) {
      // now execute the generated script compiling and generating the shared lib
      path = gSystem->WorkingDirectory();
      gSystem->ChangeDirectory(clean_dirname.Data());
#ifndef WIN32
      gSystem->Exec("chmod +x MAKEP");
      int res = !gSystem->Exec("./MAKEP");
#else
      // not really needed for Windows but it would work both both Unix and NT
      chmod("makep.cmd",00700);
      int res = !gSystem->Exec("MAKEP");
#endif
      gSystem->ChangeDirectory(path);
      path.Form("%s/%s.%s",clean_dirname.Data(),subdirname.Data(),gSystem->GetSoExt());
      if (res) printf("Shared lib %s has been generated\n",path.Data());

      //dynamically link the generated shared lib
      if (opt.Contains("++")) {
         res = !gSystem->Load(path);
         if (res) printf("Shared lib %s has been dynamically linked\n",path.Data());
      }
   }

   extrainfos.Clear("nodelete");
   // filelist->Clear("nodetele");
   delete list;
   filelist->Delete();
   delete filelist;
}

//______________________________________________________________________________
Int_t TFile::MakeProjectParMake(const char *pack, const char *filemake)
{
   // Create makefile at 'filemake' for PAR package 'pack'.
   // Called by MakeProject when option 'par' is given.
   // Return 0 on success, -1 on error.

   // Output file path must be defined
   if (!filemake || (filemake && strlen(filemake) <= 0)) {
      Error("MakeProjectParMake", "path for output file undefined!");
      return -1;
   }

   // Package name must be defined
   if (!pack || (pack && strlen(pack) <= 0)) {
      Error("MakeProjectParMake", "package name undefined!");
      return -1;
   }

#ifdef R__WINGCC
   FILE *fmk = fopen(filemake, "wb");
#else
   FILE *fmk = fopen(filemake, "w");
#endif
   if (!fmk) {
      Error("MakeProjectParMake", "cannot create file '%s' (errno: %d)", filemake, TSystem::GetErrno());
      return -1;
   }

   // Fill the file now
   fprintf(fmk, "# Makefile for the ROOT test programs.\n");
   fprintf(fmk, "# This Makefile shows how to compile and link applications\n");
   fprintf(fmk, "# using the ROOT libraries on all supported platforms.\n");
   fprintf(fmk, "#\n");
   fprintf(fmk, "# Copyright (c) 2000 Rene Brun and Fons Rademakers\n");
   fprintf(fmk, "#\n");
   fprintf(fmk, "# Author: this makefile has been automatically generated via TFile::MakeProject\n");
   fprintf(fmk, "\n");
   fprintf(fmk, "include Makefile.arch\n");
   fprintf(fmk, "\n");
   fprintf(fmk, "#------------------------------------------------------------------------------\n");
   fprintf(fmk, "\n");
   fprintf(fmk, "PACKO        = %sProjectSource.$(ObjSuf)\n", pack);
   fprintf(fmk, "PACKS        = %sProjectSource.$(SrcSuf) %sProjectDict.$(SrcSuf)\n", pack, pack);
   fprintf(fmk, "PACKSO       = lib%s.$(DllSuf)\n", pack);
   fprintf(fmk, "\n");
   fprintf(fmk, "ifeq ($(PLATFORM),win32)\n");
   fprintf(fmk, "PACKLIB      = lib%s.lib\n", pack);
   fprintf(fmk, "else\n");
   fprintf(fmk, "PACKLIB      = $(PACKSO)\n");
   fprintf(fmk, "endif\n");
   fprintf(fmk, "\n");
   fprintf(fmk, "OBJS          = $(PACKO)\n");
   fprintf(fmk, "\n");
   fprintf(fmk, "PROGRAMS      =\n");
   fprintf(fmk, "\n");
   fprintf(fmk, "#------------------------------------------------------------------------------\n");
   fprintf(fmk, "\n");
   fprintf(fmk, ".SUFFIXES: .$(SrcSuf) .$(ObjSuf) .$(DllSuf)\n");
   fprintf(fmk, "\n");
   fprintf(fmk, "all:            $(PACKLIB)\n");
   fprintf(fmk, "\n");
   fprintf(fmk, "$(PACKSO):     $(PACKO)\n");
   fprintf(fmk, "ifeq ($(ARCH),aix)\n");
   fprintf(fmk, "\t\t/usr/ibmcxx/bin/makeC++SharedLib $(OutPutOpt) $@ $(LIBS) -p 0 $^\n");
   fprintf(fmk, "else\n");
   fprintf(fmk, "ifeq ($(ARCH),aix5)\n");
   fprintf(fmk, "\t\t/usr/vacpp/bin/makeC++SharedLib $(OutPutOpt) $@ $(LIBS) -p 0 $^\n");
   fprintf(fmk, "else\n");
   fprintf(fmk, "ifeq ($(PLATFORM),macosx)\n");
   fprintf(fmk, "# We need to make both the .dylib and the .so\n");
   fprintf(fmk, "\t\t$(LD) $(SOFLAGS)$@ $(LDFLAGS) $^ $(OutPutOpt) $@ $(LIBS)\n");
   fprintf(fmk, "ifneq ($(subst $(MACOSX_MINOR),,1234),1234)\n");
   fprintf(fmk, "ifeq ($(MACOSX_MINOR),4)\n");
   fprintf(fmk, "\t\tln -sf $@ $(subst .$(DllSuf),.so,$@)\n");
   fprintf(fmk, "else\n");
   fprintf(fmk, "\t\t$(LD) -bundle -undefined $(UNDEFOPT) $(LDFLAGS) $^ \\\n");
   fprintf(fmk, "\t\t   $(OutPutOpt) $(subst .$(DllSuf),.so,$@)\n");
   fprintf(fmk, "endif\n");
   fprintf(fmk, "endif\n");
   fprintf(fmk, "else\n");
   fprintf(fmk, "ifeq ($(PLATFORM),win32)\n");
   fprintf(fmk, "\t\tbindexplib $* $^ > $*.def\n");
   fprintf(fmk, "\t\tlib -nologo -MACHINE:IX86 $^ -def:$*.def \\\n");
   fprintf(fmk, "\t\t   $(OutPutOpt)$(PACKLIB)\n");
   fprintf(fmk, "\t\t$(LD) $(SOFLAGS) $(LDFLAGS) $^ $*.exp $(LIBS) \\\n");
   fprintf(fmk, "\t\t   $(OutPutOpt)$@\n");
   fprintf(fmk, "else\n");
   fprintf(fmk, "\t\t$(LD) $(SOFLAGS) $(LDFLAGS) $^ $(OutPutOpt) $@ $(LIBS) $(EXPLLINKLIBS)\n");
   fprintf(fmk, "endif\n");
   fprintf(fmk, "endif\n");
   fprintf(fmk, "endif\n");
   fprintf(fmk, "endif\n");
   fprintf(fmk, "\t\t@echo \"$@ done\"\n");
   fprintf(fmk, "\n");
   fprintf(fmk, "clean:\n");
   fprintf(fmk, "\t\t@rm -f $(OBJS) core\n");
   fprintf(fmk, "\n");
   fprintf(fmk, "distclean:      clean\n");
   fprintf(fmk, "\t\t@rm -f $(PROGRAMS) $(PACKSO) $(PACKLIB) *Dict.* *.def *.exp \\\n");
   fprintf(fmk, "\t\t   *.so *.lib *.dll *.d *.log .def so_locations\n");
   fprintf(fmk, "\t\t@rm -rf cxx_repository\n");
   fprintf(fmk, "\n");
   fprintf(fmk, "# Dependencies\n");
   fprintf(fmk, "\n");
   fprintf(fmk, "%sProjectSource.$(ObjSuf): %sProjectHeaders.h %sLinkDef.h %sProjectDict.$(SrcSuf)\n", pack, pack, pack, pack);
   fprintf(fmk, "\n");
   fprintf(fmk, "%sProjectDict.$(SrcSuf): %sProjectHeaders.h %sLinkDef.h\n", pack, pack, pack);
   fprintf(fmk, "\t\t@echo \"Generating dictionary $@...\"\n");
   fprintf(fmk, "\t\t@rootcint -f $@ -c $^\n");
   fprintf(fmk, "\n");
   fprintf(fmk, ".$(SrcSuf).$(ObjSuf):\n");
   fprintf(fmk, "\t\t$(CXX) $(CXXFLAGS) -c $<\n");
   fprintf(fmk, "\n");

   // Close the file
   fclose(fmk);

   // Done
   return 0;
}

//______________________________________________________________________________
Int_t TFile::MakeProjectParProofInf(const char *pack, const char *proofinf)
{
   // Create BUILD.sh and SETUP.C under 'proofinf' for PAR package 'pack'.
   // Called by MakeProject when option 'par' is given.
   // Return 0 on success, -1 on error.

   // Output directory path must be defined ...
   if (!proofinf || (proofinf && strlen(proofinf) <= 0)) {
      Error("MakeProjectParProofInf", "directory path undefined!");
      return -1;
   }

   // ... and exist and be a directory
   Int_t rcst = 0;
   FileStat_t st;
   if ((rcst = gSystem->GetPathInfo(proofinf, st)) != 0 || !R_ISDIR(st.fMode)) {
      Error("MakeProjectParProofInf", "path '%s' %s", proofinf,
                       ((rcst == 0) ? "is not a directory" : "does not exist"));
      return -1;
   }

   // Package name must be defined
   if (!pack || (pack && strlen(pack) <= 0)) {
      Error("MakeProjectParProofInf", "package name undefined!");
      return -1;
   }

   TString path;

   // The BUILD.sh first
   path.Form("%s/BUILD.sh", proofinf);
#ifdef R__WINGCC
   FILE *f = fopen(path.Data(), "wb");
#else
   FILE *f = fopen(path.Data(), "w");
#endif
   if (!f) {
      Error("MakeProjectParProofInf", "cannot create file '%s' (errno: %d)",
                                      path.Data(), TSystem::GetErrno());
      return -1;
   }

   fprintf(f, "#! /bin/sh\n");
   fprintf(f, "# Build libEvent library.\n");
   fprintf(f, "\n");
   fprintf(f, "#\n");
   fprintf(f, "# The environment variables ROOTPROOFLITE and ROOTPROOFCLIENT can be used to\n");
   fprintf(f, "# adapt the script to the calling environment\n");
   fprintf(f, "#\n");
   fprintf(f, "# if test ! \"x$ROOTPROOFLITE\" = \"x\"; then\n");
   fprintf(f, "#    echo \"event-BUILD: PROOF-Lite node (session has $ROOTPROOFLITE workers)\"\n");
   fprintf(f, "# elif test ! \"x$ROOTPROOFCLIENT\" = \"x\"; then\n");
   fprintf(f, "#    echo \"event-BUILD: PROOF client\"\n");
   fprintf(f, "# else\n");
   fprintf(f, "#    echo \"event-BUILD: standard PROOF node\"\n");
   fprintf(f, "# fi\n");
   fprintf(f, "\n");
   fprintf(f, "if [ \"\" = \"clean\" ]; then\n");
   fprintf(f, "   make distclean\n");
   fprintf(f, "   exit 0\n");
   fprintf(f, "fi\n");
   fprintf(f, "\n");
   fprintf(f, "make\n");
   fprintf(f, "rc=$?\n");
   fprintf(f, "echo \"rc=$?\"\n");
   fprintf(f, "if [ $? != \"0\" ] ; then\n");
   fprintf(f, "   exit 1\n");
   fprintf(f, "fi\n");
   fprintf(f, "exit 0\n");

   // Close the file
   fclose(f);

   // Then SETUP.C
   path.Form("%s/SETUP.C", proofinf);
#ifdef R__WINGCC
   f = fopen(path.Data(), "wb");
#else
   f = fopen(path.Data(), "w");
#endif
   if (!f) {
      Error("MakeProjectParProofInf", "cannot create file '%s' (errno: %d)",
                                      path.Data(), TSystem::GetErrno());
      return -1;
   }

   fprintf(f, "Int_t SETUP()\n");
   fprintf(f, "{\n");
   fprintf(f, "\n");
   fprintf(f, "//\n");
   fprintf(f, "// The environment variables ROOTPROOFLITE and ROOTPROOFCLIENT can be used to\n");
   fprintf(f, "// adapt the macro to the calling environment\n");
   fprintf(f, "//\n");
   fprintf(f, "//   if (gSystem->Getenv(\"ROOTPROOFLITE\")) {\n");
   fprintf(f, "//      Printf(\"event-SETUP: PROOF-Lite node (session has %%s workers)\",\n");
   fprintf(f, "//                                   gSystem->Getenv(\"ROOTPROOFLITE\"));\n");
   fprintf(f, "//   } else if (gSystem->Getenv(\"ROOTPROOFCLIENT\")) {\n");
   fprintf(f, "//      Printf(\"event-SETUP: PROOF client\");\n");
   fprintf(f, "//   } else {\n");
   fprintf(f, "//      Printf(\"event-SETUP: standard PROOF node\");\n");
   fprintf(f, "//   }\n");
   fprintf(f, "\n");
   fprintf(f, "   if (gSystem->Load(\"lib%s\") == -1)\n", pack);
   fprintf(f, "      return -1;\n");
   fprintf(f, "   return 0;\n");
   fprintf(f, "}\n");
   fprintf(f, "\n");

   // Close the file
   fclose(f);

   // Done
   return 0;
}

//______________________________________________________________________________
void TFile::ReadStreamerInfo()
{
   // Read the list of StreamerInfo from this file.
   // The key with name holding the list of TStreamerInfo objects is read.
   // The corresponding TClass objects are updated.
   // Note that this function is not called if the static member fgReadInfo is falsse.
   //  (see TFile::SetReadStreamerInfo)

   TList *list = GetStreamerInfoList();
   if (!list) {
      MakeZombie();
      return;
   }

   list->SetOwner(kFALSE);

   if (gDebug > 0) Info("ReadStreamerInfo", "called for file %s",GetName());

   TStreamerInfo *info;

   Int_t version = fVersion;
   if (version > 1000000) version -= 1000000;
   if (version < 53419 || (59900 < version && version < 59907)) {
      // We need to update the fCheckSum field of the TStreamerBase.

      // loop on all TStreamerInfo classes
      TObjLink *lnk = list->FirstLink();
      while (lnk) {
         info = (TStreamerInfo*)lnk->GetObject();
         if (info == 0 || info->IsA() != TStreamerInfo::Class()) {
            lnk = lnk->Next();
            continue;
         }
         TIter next(info->GetElements());
         TStreamerElement *element;
         while ((element = (TStreamerElement*) next())) {
            TStreamerBase *base = dynamic_cast<TStreamerBase*>(element);
            if (!base) continue;
            if (base->GetBaseCheckSum() != 0) continue;
            TStreamerInfo *baseinfo = (TStreamerInfo*)list->FindObject(base->GetName());
            if (baseinfo) {
               base->SetBaseCheckSum(baseinfo->GetCheckSum());
            }
         }
         lnk = lnk->Next();
      }
   }

   // loop on all TStreamerInfo classes
   for (int mode=0;mode<2; ++mode) {
      // In order for the collection proxy to be initialized properly, we need
      // to setup the TStreamerInfo for non-stl class before the stl classes.
      TObjLink *lnk = list->FirstLink();
      while (lnk) {
         info = (TStreamerInfo*)lnk->GetObject();
         if (info == 0) {
            lnk = lnk->Next();
            continue;
         }
         if (info->IsA() != TStreamerInfo::Class()) {
            if (mode==1) {
               TObject *obj = (TObject*)info;
               if (strcmp(obj->GetName(),"listOfRules")==0) {
#if 0
                  // Completely ignore the rules for now.
                  TList *listOfRules = (TList*)obj;
                  TObjLink *rulelnk = listOfRules->FirstLink();
                  while (rulelnk) {
                     TObjString *rule = (TObjString*)rulelnk->GetObject();
                     TClass::AddRule( rule->String().Data() );
                     rulelnk = rulelnk->Next();
                  }
#endif
               } else {
                  Warning("ReadStreamerInfo","%s has a %s in the list of TStreamerInfo.", GetName(), info->IsA()->GetName());
               }
               info->SetBit(kCanDelete);
            }
            lnk = lnk->Next();
            continue;
         }
         // This is a quick way (instead of parsing the name) to see if this is
         // the description of an STL container.
         if (info->GetElements()==0) {
            Warning("ReadStreamerInfo","The StreamerInfo for %s does not have a list of elements.",info->GetName());
            lnk = lnk->Next();
            continue;
         }
         TObject *element = info->GetElements()->UncheckedAt(0);
         Bool_t isstl = element && strcmp("This",element->GetName())==0;

         if ( (!isstl && mode ==0) || (isstl && mode ==1) ) {
               // Skip the STL container the first time around
               // Skip the regular classes the second time around;
            info->BuildCheck(this);
            Int_t uid = info->GetNumber();
            Int_t asize = fClassIndex->GetSize();
            if (uid >= asize && uid <100000) fClassIndex->Set(2*asize);
            if (uid >= 0 && uid < fClassIndex->GetSize()) fClassIndex->fArray[uid] = 1;
            else {
               printf("ReadStreamerInfo, class:%s, illegal uid=%d\n",info->GetName(),uid);
            }
            if (gDebug > 0) printf(" -class: %s version: %d info read at slot %d\n",info->GetName(), info->GetClassVersion(),uid);
         }
         lnk = lnk->Next();
      }
   }
   fClassIndex->fArray[0] = 0;
   list->Clear();  //this will delete all TStreamerInfo objects with kCanDelete bit set
   delete list;
}

//______________________________________________________________________________
void TFile::SetReadStreamerInfo(Bool_t readinfo)
{
   // static function to set fgReadInfo.
   // If fgReadInfo is true (default) TFile::ReadStreamerInfo is called
   //  when opening the file.
   // It may be interesting to set fgReadInfo to false to speedup the file
   // opening time or in case libraries containing classes referenced
   // by the file have not yet been loaded.
   // if fgReadInfo is false, one can still read the StreamerInfo with
   //    myfile.ReadStreamerInfo();

   fgReadInfo = readinfo;
}

//______________________________________________________________________________
Bool_t TFile::GetReadStreamerInfo()
{
   // static function to get the value of fgReadInfo.
   // See TFile::SetReadStreamerInfo for more documentation.

   return fgReadInfo;
}

//______________________________________________________________________________
void TFile::ShowStreamerInfo()
{
   // Show the StreamerInfo of all classes written to this file.

   TList *list = GetStreamerInfoList();
   if (!list) return;

   list->ls();
   delete list;
}

//______________________________________________________________________________
UShort_t TFile::WriteProcessID(TProcessID *pidd)
{
   // Check if the ProcessID pidd is already in the file,
   // if not, add it and return the index  number in the local file list.

   TProcessID *pid = pidd;
   if (!pid) pid = TProcessID::GetPID();
   TObjArray *pids = GetListOfProcessIDs();
   Int_t npids = GetNProcessIDs();
   for (Int_t i=0;i<npids;i++) {
      if (pids->At(i) == pid) return (UShort_t)i;
   }

   this->SetBit(TFile::kHasReferences);
   pids->AddAtAndExpand(pid,npids);
   pid->IncrementCount();
   char name[32];
   snprintf(name,32,"ProcessID%d",npids);
   this->WriteTObject(pid,name);
   this->IncrementProcessIDs();
   if (gDebug > 0) {
      Info("WriteProcessID", "name=%s, file=%s", name, GetName());
   }
   return (UShort_t)npids;
}


//______________________________________________________________________________
void TFile::WriteStreamerInfo()
{
   // Write the list of TStreamerInfo as a single object in this file
   // The class Streamer description for all classes written to this file
   // is saved. See class TStreamerInfo.

   //if (!gFile) return;
   if (!fWritable) return;
   if (!fClassIndex) return;
   if (fIsPcmFile) return; // No schema evolution for ROOT PCM files.
   //no need to update the index if no new classes added to the file
   if (fClassIndex->fArray[0] == 0) return;
   if (gDebug > 0) Info("WriteStreamerInfo", "called for file %s",GetName());

   SafeDelete(fInfoCache);

   // build a temporary list with the marked files
   TIter next(gROOT->GetListOfStreamerInfo());
   TStreamerInfo *info;
   TList list;
   TList listOfRules;
   listOfRules.SetOwner(kTRUE);
   listOfRules.SetName("listOfRules");
   std::set<TClass*> classSet;


   while ((info = (TStreamerInfo*)next())) {
      Int_t uid = info->GetNumber();
      if (fClassIndex->fArray[uid]) {
         list.Add(info);
         if (gDebug > 0) printf(" -class: %s info number %d saved\n",info->GetName(),uid);

         // Add the IO customization rules to the list to be saved for the underlying
         // class but make sure to add them only once.
         TClass *clinfo = info->GetClass();
         if (clinfo && clinfo->GetSchemaRules()) {
            if ( classSet.find( clinfo ) == classSet.end() ) {
               if (gDebug > 0) printf(" -class: %s stored the I/O customization rules\n",info->GetName());

               TObjArrayIter it( clinfo->GetSchemaRules()->GetRules() );
               ROOT::TSchemaRule *rule;
               while( (rule = (ROOT::TSchemaRule*)it.Next()) ) {
                  TObjString *obj = new TObjString();
                  rule->AsString(obj->String());
                  listOfRules.Add(obj);
               }
               classSet.insert(clinfo);
            }
         }
      }
   }

   // Write the StreamerInfo list even if it is empty.
   fClassIndex->fArray[0] = 2; //to prevent adding classes in TStreamerInfo::TagFile

   if (listOfRules.GetEntries()) {
      // Only add the list of rules if we have something to say.
      list.Add(&listOfRules);
   }

   // always write with compression on
   Int_t compress = fCompress;
   fCompress = 1;

   //free previous StreamerInfo record
   if (fSeekInfo) MakeFree(fSeekInfo,fSeekInfo+fNbytesInfo-1);
   //Create new key
   TKey key(&list,"StreamerInfo",GetBestBuffer(), this);
   fKeys->Remove(&key);
   fSeekInfo   = key.GetSeekKey();
   fNbytesInfo = key.GetNbytes();
   SumBuffer(key.GetObjlen());
   key.WriteFile(0);

   fClassIndex->fArray[0] = 0;
   fCompress = compress;

   list.RemoveLast(); // remove the listOfRules.
}

//______________________________________________________________________________
TFile *TFile::OpenFromCache(const char *name, Option_t *, const char *ftitle,
                   Int_t compress, Int_t netopt)
{
   // Static member function allowing to open a file for reading through the file
   // cache. The file will be downloaded to the cache and opened from there.
   // If the download fails, it will be opened remotely.
   // The file will be downloaded to the directory specified by SetCacheFileDir().

   TFile *f = 0;

   if (fgCacheFileDir == "") {
      ::Warning("TFile::OpenFromCache",
                "you want to read through a cache, but you have no valid cache "
                "directory set - reading remotely");
      ::Info("TFile::OpenFromCache", "set cache directory using TFile::SetCacheFileDir()");
   } else {
      TUrl fileurl(name);
      TUrl tagurl;

      if ((!strcmp(fileurl.GetProtocol(), "file"))) {
         // it makes no sense to read local files through a file cache
         if (!fgCacheFileForce)
            ::Warning("TFile::OpenFromCache",
                      "you want to read through a cache, but you are reading "
                      "local files - CACHEREAD disabled");
      } else {
         // this is a remote file and worthwhile to be put into the local cache
         // now create cachepath to put it
         TString cachefilepath;
         TString cachefilepathbasedir;
         cachefilepath = fgCacheFileDir;
         cachefilepath += fileurl.GetFile();
         cachefilepathbasedir = gSystem->DirName(cachefilepath);
         if ((gSystem->mkdir(cachefilepathbasedir, kTRUE) < 0) &&
               (gSystem->AccessPathName(cachefilepathbasedir, kFileExists))) {
            ::Warning("TFile::OpenFromCache","you want to read through a cache, but I "
                      "cannot create the directory %s - CACHEREAD disabled",
                      cachefilepathbasedir.Data());
         } else {
            // check if this should be a zip file
            if (strlen(fileurl.GetAnchor())) {
               // remove the anchor and change the target name
               cachefilepath += "__";
               cachefilepath += fileurl.GetAnchor();
               fileurl.SetAnchor("");
            }
            if (strstr(name,"zip=")) {
               // filter out this option and change the target cache name
               TString urloptions = fileurl.GetOptions();
               TString newoptions;
               TObjArray *objOptions = urloptions.Tokenize("&");
               Int_t optioncount = 0;
               TString zipname;
               for (Int_t n = 0; n < objOptions->GetEntries(); n++) {
                  TString loption = ((TObjString*)objOptions->At(n))->GetName();
                  TObjArray *objTags = loption.Tokenize("=");
                  if (objTags->GetEntries() == 2) {
                     TString key   = ((TObjString*)objTags->At(0))->GetName();
                     TString value = ((TObjString*)objTags->At(1))->GetName();
                     if (key.CompareTo("zip", TString::kIgnoreCase)) {
                        if (optioncount!=0) {
                           newoptions += "&";
                        }
                        newoptions += key;
                        newoptions += "=";
                        newoptions += value;
                        ++optioncount;
                     } else {
                        zipname = value;
                     }
                  }
                  delete objTags;
               }
               delete objOptions;
               fileurl.SetOptions(newoptions.Data());
               cachefilepath += "__";
               cachefilepath += zipname;
               fileurl.SetAnchor("");
            }

            Bool_t need2copy = kFALSE;

            // check if file is in the cache
            Long_t id;
            Long64_t size;
            Long_t flags;
            Long_t modtime;
            if (!gSystem->GetPathInfo(cachefilepath, &id, &size, &flags, &modtime)) {
               // file is in the cache
               if (!fgCacheFileDisconnected) {
                  char cacheblock[256];
                  char remotblock[256];
                  // check the remote file for it's size and compare some magic bytes
                  TString cfurl;
                  cfurl = cachefilepath;
                  cfurl += "?filetype=raw";
                  TUrl rurl(name);
                  TString ropt = rurl.GetOptions();
                  ropt += "&filetype=raw";
                  rurl.SetOptions(ropt);

                  Bool_t forcedcache = fgCacheFileForce;
                  fgCacheFileForce = kFALSE;

                  TFile *cachefile = TFile::Open(cfurl, "READ");
                  TFile *remotfile = TFile::Open(rurl.GetUrl(), "READ");

                  fgCacheFileForce = forcedcache;

                  if (!cachefile) {
                     need2copy = kTRUE;
                     ::Error("TFile::OpenFromCache",
                             "cannot open the cache file to check cache consistency");
                     return 0;
                  }

                  if (!remotfile) {
                     ::Error("TFile::OpenFromCache",
                             "cannot open the remote file to check cache consistency");
                     return 0;
                  }

                  cachefile->Seek(0);
                  remotfile->Seek(0);

                  if ((!cachefile->ReadBuffer(cacheblock,256)) &&
                      (!remotfile->ReadBuffer(remotblock,256))) {
                     if (memcmp(cacheblock, remotblock, 256)) {
                        ::Warning("TFile::OpenFromCache", "the header of the cache file "
                                  "differs from the remote file - forcing an update");
                        need2copy = kTRUE;
                     }
                  } else {
                     ::Warning("TFile::OpenFromCache", "the header of the cache and/or "
                               "remote file are not readable - forcing an update");
                     need2copy = kTRUE;
                  }

                  delete remotfile;
                  delete cachefile;
               }
            } else {
               need2copy = kTRUE;
            }

            // try to fetch the file (disable now the forced caching)
            Bool_t forcedcache = fgCacheFileForce;
            fgCacheFileForce = kFALSE;
            if (need2copy && !TFile::Cp(name, cachefilepath)) {
               ::Warning("TFile::OpenFromCache", "you want to read through a cache, but I "
                         "cannot make a cache copy of %s - CACHEREAD disabled",
                         cachefilepathbasedir.Data());
               fgCacheFileForce = forcedcache;
               if (fgOpenTimeout != 0)
                  return 0;
            } else {
               fgCacheFileForce = forcedcache;
               ::Info("TFile::OpenFromCache", "using local cache copy of %s [%s]",
                       name, cachefilepath.Data());
               // finally we have the file and can open it locally
               fileurl.SetProtocol("file");
               fileurl.SetFile(cachefilepath);

               tagurl = fileurl;
               TString tagfile;
               tagfile = cachefilepath;
               tagfile += ".ROOT.cachefile";
               tagurl.SetFile(tagfile);
               // we symlink this file as a ROOT cached file
               gSystem->Symlink(gSystem->BaseName(cachefilepath), tagfile);
               return TFile::Open(fileurl.GetUrl(), "READ", ftitle, compress, netopt);
            }
         }
      }
   }

   // Failed
   return f;
}

//______________________________________________________________________________
TFile *TFile::Open(const char *url, Option_t *options, const char *ftitle,
                   Int_t compress, Int_t netopt)
{
   // Static member function allowing the creation/opening of either a
   // TFile, TNetFile, TWebFile or any TFile derived class for which an
   // plugin library handler has been registered with the plugin manager
   // (for the plugin manager see the TPluginManager class). The returned
   // type of TFile depends on the file name specified by 'url'.
   // If 'url' is a '|'-separated list of file URLs, the 'URLs' are tried
   // sequentially in the specified order until a successful open.
   // If the file starts with "root:", "roots:" or "rootk:" a TNetFile object
   // will be returned, with "http:" a TWebFile, with "file:" a local TFile,
   // etc. (see the list of TFile plugin handlers in $ROOTSYS/etc/system.rootrc
   // for regular expressions that will be checked) and as last a local file will
   // be tried.
   // Before opening a file via TNetFile a check is made to see if the URL
   // specifies a local file. If that is the case the file will be opened
   // via a normal TFile. To force the opening of a local file via a
   // TNetFile use either TNetFile directly or specify as host "localhost".
   // The netopt argument is only used by TNetFile. For the meaning of the
   // options and other arguments see the constructors of the individual
   // file classes. In case of error returns 0.
   //
   // For TFile implementations supporting asynchronous file open, see
   // TFile::AsyncOpen(...), it is possible to request a timeout with the
   // option:
   //  TIMEOUT=<secs>   the timeout must be specified in seconds and
   //                   it will be internally checked with granularity of
   //                   one millisec.
   //
   // For remote files there is the option:
   //  CACHEREAD     opens an existing file for reading through the file cache.
   //                The file will be downloaded to the cache and opened from there.
   //                If the download fails, it will be opened remotely.
   //                The file will be downloaded to the directory specified by
   //                SetCacheFileDir().

   TPluginHandler *h;
   TFile *f = 0;
   EFileType type = kFile;

   // Check input
   if (!url || strlen(url) <= 0) {
      ::Error("TFile::Open", "no url specified");
      return f;
   }

   TString expandedUrl(url);
   gSystem->ExpandPathName(expandedUrl);

   // If a timeout has been specified extract the value and try to apply it (it requires
   // support for asynchronous open, though; the following is completely transparent if
   // such support if not available for the required protocol)
   TString opts(options);
   Int_t ito = opts.Index("TIMEOUT=");
   if (ito != kNPOS) {
      TString sto = opts(ito + strlen("TIMEOUT="), opts.Length());
      while (!(sto.IsDigit()) && !(sto.IsNull())) { sto.Remove(sto.Length()-1,1); }
      if (!(sto.IsNull())) {
         // Timeout in millisecs
         Int_t toms = sto.Atoi() * 1000;
         if (gDebug > 0) ::Info("TFile::Open", "timeout of %d millisec requested", toms);
         // Remove from the options field
         sto.Insert(0, "TIMEOUT=");
         opts.ReplaceAll(sto, "");
         // Asynchrounous open
         TFileOpenHandle *fh = TFile::AsyncOpen(expandedUrl, opts, ftitle, compress, netopt);
         // Check the result in steps of 1 millisec
         TFile::EAsyncOpenStatus aos = TFile::kAOSNotAsync;
         aos = TFile::GetAsyncOpenStatus(fh);
         Int_t xtms = toms;
         while (aos != TFile::kAOSNotAsync && aos == TFile::kAOSInProgress && xtms > 0) {
            gSystem->Sleep(1);
            xtms -= 1;
            aos = TFile::GetAsyncOpenStatus(fh);
         }
         if (aos == TFile::kAOSNotAsync || aos == TFile::kAOSSuccess) {
            // Do open the file now
            f = TFile::Open(fh);
            if (gDebug > 0) {
               if (aos == TFile::kAOSSuccess)
                  ::Info("TFile::Open", "waited %d millisec for asynchronous open", toms - xtms);
               else
                  ::Info("TFile::Open", "timeout option not supported (requires asynchronous"
                                        " open support)");
            }
         } else {
            if (xtms <= 0)
               ::Error("TFile::Open", "timeout expired while opening '%s'", expandedUrl.Data());
            // Cleanup the request
            SafeDelete(fh);
         }
         // Done
         return f;
      } else {
         ::Warning("TFile::Open", "incomplete 'TIMEOUT=' option specification - ignored");
         opts.ReplaceAll("TIMEOUT=", "");
      }
   }

   // We will use this from now on
   const char *option = opts;

   // Many URLs? Redirect output and print errors in case of global failure
   TString namelist(expandedUrl);
   Ssiz_t ip = namelist.Index("|");
   Bool_t rediroutput = (ip != kNPOS &&
                         ip != namelist.Length()-1 && gDebug <= 0) ? kTRUE : kFALSE;
   RedirectHandle_t rh;
   if (rediroutput) {
      TString outf = ".TFileOpen_";
      FILE *fout = gSystem->TempFileName(outf);
      if (fout) {
         fclose(fout);
         gSystem->RedirectOutput(outf, "w", &rh);
      }
   }

   // Try sequentially all names in 'names'
   TString name, n;
   Ssiz_t from = 0;
   while (namelist.Tokenize(n, from, "|") && !f) {

      // check if we read through a file cache
      if (!strcasecmp(option, "CACHEREAD") ||
         ((!strcasecmp(option,"READ") || !option[0]) && fgCacheFileForce)) {
         // Try opening the file from the cache
         if ((f = TFile::OpenFromCache(n, option, ftitle, compress, netopt)))
            return f;
      }

      IncrementFileCounter();

      // change names from e.g. /castor/cern.ch/alice/file.root to
      // castor:/castor/cern.ch/alice/file.root as recognized by the plugin manager
      TUrl urlname(n, kTRUE);
      name = urlname.GetUrl();
      // Check first if a pending async open request matches this one
      if (fgAsyncOpenRequests && (fgAsyncOpenRequests->GetSize() > 0)) {
         TIter nxr(fgAsyncOpenRequests);
         TFileOpenHandle *fh = 0;
         while ((fh = (TFileOpenHandle *)nxr()))
            if (fh->Matches(name))
               return TFile::Open(fh);
      }

      TString urlOptions(urlname.GetOptions());
      if (urlOptions.BeginsWith("pmerge") || urlOptions.Contains("&pmerge") || urlOptions.Contains(" pmerge")) {
         type = kMerge;

         // Pass the full name including the url options:
         f = (TFile*) gROOT->ProcessLineFast(TString::Format("new TParallelMergingFile(\"%s\",\"%s\",\"%s\",%d)",n.Data(),option,ftitle,compress));

      } else {
         // Resolve the file type; this also adjusts names
         TString lfname = gEnv->GetValue("Path.Localroot", "");
         type = GetType(name, option, &lfname);

         if (type == kLocal) {

            // Local files
            if (lfname.IsNull()) {
               urlname.SetHost("");
               urlname.SetProtocol("file");
               lfname = urlname.GetUrl();
            }
            f = new TFile(lfname.Data(), option, ftitle, compress);

         } else if (type == kNet) {

            // Network files
            if ((h = gROOT->GetPluginManager()->FindHandler("TFile", name))) {
               if (h->LoadPlugin() == -1)
                  return 0;
               f = (TFile*) h->ExecPlugin(5, name.Data(), option, ftitle, compress, netopt);
            }

         } else if (type == kWeb) {

            // Web files
            if ((h = gROOT->GetPluginManager()->FindHandler("TFile", name))) {
               if (h->LoadPlugin() == -1)
                  return 0;
               f = (TFile*) h->ExecPlugin(2, name.Data(), option);
            }

         } else if (type == kFile) {

            // 'file:' protocol
            if ((h = gROOT->GetPluginManager()->FindHandler("TFile", name)) &&
                h->LoadPlugin() == 0) {
               name.ReplaceAll("file:", "");
               f = (TFile*) h->ExecPlugin(4, name.Data(), option, ftitle, compress);
            } else
               f = new TFile(name.Data(), option, ftitle, compress);

         } else {

            // no recognized specification: try the plugin manager
            if ((h = gROOT->GetPluginManager()->FindHandler("TFile", name.Data()))) {
               if (h->LoadPlugin() == -1)
                  return 0;
               TClass *cl = TClass::GetClass(h->GetClass());
               if (cl && cl->InheritsFrom("TNetFile"))
                  f = (TFile*) h->ExecPlugin(5, name.Data(), option, ftitle, compress, netopt);
               else
                  f = (TFile*) h->ExecPlugin(4, name.Data(), option, ftitle, compress);
            } else {
               // Just try to open it locally but via TFile::Open, so that we pick-up the correct
               // plug-in in the case file name contains information about a special backend (e.g.
               // "srm://srm.cern.ch//castor/cern.ch/grid/..." should be considered a castor file
               // /castor/cern.ch/grid/...").
               f = TFile::Open(urlname.GetFileAndOptions(), option, ftitle, compress);
            }
         }
      }

      if (f && f->IsZombie()) {
         TString newUrl = f->GetNewUrl();
         delete f;
         if( newUrl.Length() && gEnv->GetValue("TFile.CrossProtocolRedirects", 1) )
            f = TFile::Open( newUrl, option, ftitle, compress );
         else
            f = 0;
      }
   }

   if (rediroutput) {
      // Restore output to stdout
      gSystem->RedirectOutput(0, "", &rh);
      // If we failed print error messages
      if (!f)
         gSystem->ShowOutput(&rh);
      // Remove the file
      gSystem->Unlink(rh.fFile);
   }

   // if the file is writable, non local, and not opened in raw mode
   // we create a default write cache of 512 KBytes
   if (type != kLocal && type != kFile &&
       f && f->IsWritable() && !f->IsRaw()) {
      new TFileCacheWrite(f, 1);
   }

   return f;
}

//______________________________________________________________________________
TFileOpenHandle *TFile::AsyncOpen(const char *url, Option_t *option,
                                  const char *ftitle, Int_t compress,
                                  Int_t netopt)
{
   // Static member function to submit an open request. The request will be
   // processed asynchronously. See TFile::Open(const char *, ...) for an
   // explanation of the arguments. A handler is returned which is to be passed
   // to TFile::Open(TFileOpenHandle *) to get the real TFile instance once
   // the file is open.
   // This call never blocks and it is provided to allow parallel submission
   // of file opening operations expected to take a long time.
   // TFile::Open(TFileOpenHandle *) may block if the file is not yet ready.
   // The sequence
   //    TFile::Open(TFile::AsyncOpen(const char *, ...))
   // is equivalent to
   //    TFile::Open(const char *, ...) .
   // To be effective, the underlying TFile implementation must be able to
   // support asynchronous open functionality. Currently, only TXNetFile
   // supports it. If the functionality is not implemented, this call acts
   // transparently by returning an handle with the arguments for the
   // standard synchronous open run by TFile::Open(TFileOpenHandle *).
   // The retuned handle will be adopted by TFile after opening completion
   // in TFile::Open(TFileOpenHandle *); if opening is not finalized the
   // handle must be deleted by the caller.

   TFileOpenHandle *fh = 0;
   TPluginHandler *h;
   TFile *f = 0;
   Bool_t notfound = kTRUE;

   // Check input
   if (!url || strlen(url) <= 0) {
      ::Error("TFile::AsyncOpen", "no url specified");
      return fh;
   }

   // Many URLs? Redirect output and print errors in case of global failure
   TString namelist(url);
   gSystem->ExpandPathName(namelist);
   Ssiz_t ip = namelist.Index("|");
   Bool_t rediroutput = (ip != kNPOS &&
                         ip != namelist.Length()-1 && gDebug <= 0) ? kTRUE : kFALSE;
   RedirectHandle_t rh;
   if (rediroutput) {
      TString outf = ".TFileAsyncOpen_";
      FILE *fout = gSystem->TempFileName(outf);
      if (fout) {
         fclose(fout);
         gSystem->RedirectOutput(outf, "w", &rh);
      }
   }

   // Try sequentially all names in 'names'
   TString name, n;
   Ssiz_t from = 0;
   while (namelist.Tokenize(n, from, "|") && !f) {

      // change names from e.g. /castor/cern.ch/alice/file.root to
      // castor:/castor/cern.ch/alice/file.root as recognized by the plugin manager
      TUrl urlname(n, kTRUE);
      name = urlname.GetUrl();

      // Resolve the file type; this also adjusts names
      EFileType type = GetType(name, option);

      // Here we send the asynchronous request if the functionality is implemented
      if (type == kNet) {
         // Network files
         if ((h = gROOT->GetPluginManager()->FindHandler("TFile", name)) &&
            (!strcmp(h->GetClass(),"TXNetFile") || !strcmp(h->GetClass(),"TNetXNGFile"))
            && h->LoadPlugin() == 0) {
            f = (TFile*) h->ExecPlugin(6, name.Data(), option, ftitle, compress, netopt, kTRUE);
            notfound = kFALSE;
         }
      }
      if ((h = gROOT->GetPluginManager()->FindHandler("TFile", name)) &&
         !strcmp(h->GetClass(),"TAlienFile") && h->LoadPlugin() == 0) {
         f = (TFile*) h->ExecPlugin(5, name.Data(), option, ftitle, compress, kTRUE);
         notfound = kFALSE;
      }

   }

   if (rediroutput) {
      // Restore output to stdout
      gSystem->RedirectOutput(0, "", &rh);
      // If we failed print error messages
      if (!notfound && !f)
         gSystem->ShowOutput(&rh);
      // Remove the file
      gSystem->Unlink(rh.fFile);
   }

   // Make sure that no error occured
   if (notfound) {
      SafeDelete(f);
      // Save the arguments in the handler, so that a standard open can be
      // attempted later on
      fh = new TFileOpenHandle(name, option, ftitle, compress, netopt);
   } else if (f) {
      // Fill the opaque handler to be use to attach the file later on
      fh = new TFileOpenHandle(f);
   }

   // Record this request
   if (fh) {
      // Create the lst, if not done already
      if (!fgAsyncOpenRequests)
         fgAsyncOpenRequests = new TList;
      fgAsyncOpenRequests->Add(fh);
   }

   // We are done
   return fh;
}

//______________________________________________________________________________
TFile *TFile::Open(TFileOpenHandle *fh)
{
   // Waits for the completion of an asynchronous open request.
   // Returns the associated TFile, transferring ownership of the
   // handle to the TFile instance.

   TFile *f = 0;

   // Note that the request may have failed
   if (fh && fgAsyncOpenRequests) {
      // Remove it from the pending list: we need to do it at this level to avoid
      // recursive calls in the standard TFile::Open
      fgAsyncOpenRequests->Remove(fh);
      // Was asynchronous open functionality implemented?
      if ((f = fh->GetFile()) && !(f->IsZombie())) {
         // Yes: wait for the completion of the open phase, if needed
         Bool_t cr = (!strcmp(f->GetOption(),"CREATE") ||
                      !strcmp(f->GetOption(),"RECREATE") ||
                      !strcmp(f->GetOption(),"NEW")) ? kTRUE : kFALSE;
         f->Init(cr);
      } else {
         // No: process a standard open
         f = TFile::Open(fh->GetName(), fh->GetOpt(), fh->GetTitle(),
                         fh->GetCompress(), fh->GetNetOpt());
      }

      // Adopt the handle instance in the TFile instance so that it gets
      // automatically cleaned up
      if (f) f->fAsyncHandle = fh;
   }

   // We are done
   return f;
}

//______________________________________________________________________________
Int_t TFile::SysOpen(const char *pathname, Int_t flags, UInt_t mode)
{
   // Interface to system open. All arguments like in POSIX open().

#if defined(R__WINGCC)
   // ALWAYS use binary mode - even cygwin text should be in unix format
   // although this is posix default it has to be set explicitly
   return ::open(pathname, flags | O_BINARY, mode);
#elif defined(R__SEEK64)
   return ::open64(pathname, flags, mode);
#else
   return ::open(pathname, flags, mode);
#endif
}

//______________________________________________________________________________
Int_t TFile::SysClose(Int_t fd)
{
   // Interface to system close. All arguments like in POSIX close().

   if (fd < 0) return 0;
   return ::close(fd);
}

//______________________________________________________________________________
Int_t TFile::SysRead(Int_t fd, void *buf, Int_t len)
{
   // Interface to system read. All arguments like in POSIX read().

   return ::read(fd, buf, len);
}

//______________________________________________________________________________
Int_t TFile::SysWrite(Int_t fd, const void *buf, Int_t len)
{
   // Interface to system write. All arguments like in POSIX write().

   return ::write(fd, buf, len);
}
//______________________________________________________________________________
Long64_t TFile::SysSeek(Int_t fd, Long64_t offset, Int_t whence)
{
   // Interface to system lseek. All arguments like in POSIX lseek()
   // except that the offset and return value are of a type which are
   // able to handle 64 bit file systems.

#if defined (R__SEEK64)
   return ::lseek64(fd, offset, whence);
#elif defined(WIN32)
   return ::_lseeki64(fd, offset, whence);
#else
   return ::lseek(fd, offset, whence);
#endif
}

//______________________________________________________________________________
Int_t TFile::SysStat(Int_t, Long_t *id, Long64_t *size, Long_t *flags,
                     Long_t *modtime)
{
   // Return file stat information. The interface and return value is
   // identical to TSystem::GetPathInfo(). The function returns 0 in
   // case of success and 1 if the file could not be stat'ed.

   return gSystem->GetPathInfo(fRealName, id, size, flags, modtime);
}

//______________________________________________________________________________
Int_t TFile::SysSync(Int_t fd)
{
   // Interface to system fsync. All arguments like in POSIX fsync().

   if (TestBit(kDevNull)) return 0;

#ifndef WIN32
   return ::fsync(fd);
#else
   return ::_commit(fd);
#endif
}

//______________________________________________________________________________
Long64_t TFile::GetBytesWritten() const
{
   // Return the total number of bytes written so far to the file.

   return fCacheWrite ? fCacheWrite->GetBytesInCache() + fBytesWrite : fBytesWrite;
}

//______________________________________________________________________________
Long64_t TFile::GetFileBytesRead()
{
   // Static function returning the total number of bytes read from all files.

   return fgBytesRead;
}

//______________________________________________________________________________
Long64_t TFile::GetFileBytesWritten()
{
   // Static function returning the total number of bytes written to all files.
   // Does not take into account what might still be in the write caches.

   return fgBytesWrite;
}

//______________________________________________________________________________
Int_t TFile::GetFileReadCalls()
{
   // Static function returning the total number of read calls from all files.

   return fgReadCalls;
}

//______________________________________________________________________________
Int_t TFile::GetReadaheadSize()
{
   // Static function returning the readahead buffer size.

   return fgReadaheadSize;
}

//______________________________________________________________________________
void TFile::SetReadaheadSize(Int_t bytes) { fgReadaheadSize = bytes; }

//______________________________________________________________________________
void TFile::SetFileBytesRead(Long64_t bytes) { fgBytesRead = bytes; }

//______________________________________________________________________________
void TFile::SetFileBytesWritten(Long64_t bytes) { fgBytesWrite = bytes; }

//______________________________________________________________________________
void TFile::SetFileReadCalls(Int_t readcalls) { fgReadCalls = readcalls; }

//______________________________________________________________________________
Long64_t TFile::GetFileCounter() { return fgFileCounter; }

//______________________________________________________________________________
void TFile::IncrementFileCounter() { fgFileCounter++; }

//______________________________________________________________________________
Bool_t TFile::SetCacheFileDir(const char *cachedir, Bool_t operatedisconnected,
                              Bool_t forcecacheread )
{
   // Sets the directory where to locally stage/cache remote files.
   // If the directory is not writable by us return kFALSE.

   TString cached = cachedir;
   if (!cached.EndsWith("/"))
      cached += "/";

   if (gSystem->AccessPathName(cached, kFileExists)) {
      // try to create it
      gSystem->mkdir(cached, kTRUE);
      if (gSystem->AccessPathName(cached, kFileExists)) {
         ::Error("TFile::SetCacheFileDir", "no suffcient permissions on cache directory %s or cannot create it", cachedir);
         fgCacheFileDir = "";
         return kFALSE;
      }
      gSystem->Chmod(cached, 0700);
   }
   if (gSystem->AccessPathName(cached, kWritePermission))
      gSystem->Chmod(cached, 0700);
   fgCacheFileDir          = cached;
   fgCacheFileDisconnected = operatedisconnected;
   fgCacheFileForce        = forcecacheread;
   return kTRUE;
}

//______________________________________________________________________________
const char *TFile::GetCacheFileDir()
{
   // Get the directory where to locally stage/cache remote files.

   return fgCacheFileDir;
}

//______________________________________________________________________________
Bool_t TFile::ShrinkCacheFileDir(Long64_t shrinksize, Long_t cleanupinterval)
{
   // We try to shrink the cache to the desired size.
   // With the clenupinterval you can specify the minimum amount of time after
   // the previous cleanup before the cleanup operation is repeated in
   // the cache directory

   if (fgCacheFileDir == "") {
      return kFALSE;
   }

   // check the last clean-up in the cache
   Long_t id;
   Long64_t size;
   Long_t flags;
   Long_t modtime;

   TString cachetagfile = fgCacheFileDir;
   cachetagfile += ".tag.ROOT.cache";
   if (!gSystem->GetPathInfo(cachetagfile, &id, &size, &flags, &modtime)) {
      // check the time passed since last cache cleanup
      Long_t lastcleanuptime = ((Long_t)time(0) - modtime);
      if (lastcleanuptime < cleanupinterval) {
         ::Info("TFile::ShrinkCacheFileDir", "clean-up is skipped - last cleanup %lu seconds ago - you requested %lu", lastcleanuptime, cleanupinterval);
         return kTRUE;
      }
   }

   // (re-)create the cache tag file
   cachetagfile += "?filetype=raw";
   TFile *tagfile = 0;

   if (!(tagfile = TFile::Open(cachetagfile, "RECREATE"))) {
      ::Error("TFile::ShrinkCacheFileDir", "cannot create the cache tag file %s", cachetagfile.Data());
      return kFALSE;
   }

   // the shortest garbage collector in the world - one long line of PERL - unlinks files only,
   // if there is a symbolic link with '.ROOT.cachefile' for safety ;-)

   TString cmd;
#if defined(R__WIN32)
   cmd = "echo <TFile::ShrinkCacheFileDir>: cleanup to be implemented";
#elif defined(R__MACOSX)
   cmd.Format("perl -e 'my $cachepath = \"%s\"; my $cachesize = %lld;my $findcommand=\"find $cachepath -type f -exec stat -f \\\"\\%%a::\\%%N::\\%%z\\\" \\{\\} \\\\\\;\";my $totalsize=0;open FIND, \"$findcommand | sort -k 1 |\";while (<FIND>) { my ($accesstime, $filename, $filesize) = split \"::\",$_; $totalsize += $filesize;if ($totalsize > $cachesize) {if ( ( -e \"${filename}.ROOT.cachefile\" ) && ( -e \"${filename}\" ) ) {unlink \"$filename.ROOT.cachefile\";unlink \"$filename\";}}}close FIND;' ", fgCacheFileDir.Data(),shrinksize);
#else
   cmd.Format("perl -e 'my $cachepath = \"%s\"; my $cachesize = %lld;my $findcommand=\"find $cachepath -type f -exec stat -c \\\"\\%%x::\\%%n::\\%%s\\\" \\{\\} \\\\\\;\";my $totalsize=0;open FIND, \"$findcommand | sort -k 1 |\";while (<FIND>) { my ($accesstime, $filename, $filesize) = split \"::\",$_; $totalsize += $filesize;if ($totalsize > $cachesize) {if ( ( -e \"${filename}.ROOT.cachefile\" ) && ( -e \"${filename}\" ) ) {unlink \"$filename.ROOT.cachefile\";unlink \"$filename\";}}}close FIND;' ", fgCacheFileDir.Data(),shrinksize);
#endif

   tagfile->WriteBuffer(cmd, 4096);
   delete tagfile;

   if ((gSystem->Exec(cmd)) != 0) {
      ::Error("TFile::ShrinkCacheFileDir", "error executing clean-up script");
      return kFALSE;
   }

   return kTRUE;
}

//______________________________________________________________________________
UInt_t TFile::SetOpenTimeout(UInt_t timeout)
{
   // Sets open timeout time (in ms). Returns previous timeout value.

   UInt_t to = fgOpenTimeout;
   fgOpenTimeout = timeout;
   return to;
}

//______________________________________________________________________________
UInt_t TFile::GetOpenTimeout()
{
   // Returns open timeout (in ms).

   return fgOpenTimeout;
}

//______________________________________________________________________________
Bool_t TFile::SetOnlyStaged(Bool_t onlystaged)
{
   // Sets only staged flag. Returns previous value of flag.
   // When true we check before opening the file if it is staged, if not,
   // the open fails.

   Bool_t f = fgOnlyStaged;
   fgOnlyStaged = onlystaged;
   return f;
}

//______________________________________________________________________________
Bool_t TFile::GetOnlyStaged()
{
   // Returns staged only flag.

   return fgOnlyStaged;
}

//______________________________________________________________________________
Bool_t TFile::Matches(const char *url)
{
   // Return kTRUE if 'url' matches the coordinates of this file.
   // The check is implementation dependent and may need to be overload
   // by each TFile implememtation relying on this check.
   // The default implementation checks the file name only.

   // Check the full URL, including port and FQDN.
   TUrl u(url);

   // Check
   if (!strcmp(u.GetFile(), fUrl.GetFile())) {
      // Check ports
      if (u.GetPort() == fUrl.GetPort()) {
         if (!strcmp(u.GetHostFQDN(), fUrl.GetHostFQDN())) {
            // Ok, coordinates match
            return kTRUE;
         }
      }
   }

   // Default is not matching
   return kFALSE;
}

//______________________________________________________________________________
Bool_t TFileOpenHandle::Matches(const char *url)
{
   // Return kTRUE if this async request matches the open request
   // specified by 'url'

   if (fFile) {
      return fFile->Matches(url);
   } else if (fName.Length() > 0){
      // Deep check of URLs
      TUrl u(url);
      TUrl uref(fName);
      if (!strcmp(u.GetFile(), uref.GetFile())) {
         // Check ports
         if (u.GetPort() == uref.GetPort()) {
            // Check also the host name
            if (!strcmp(u.GetHostFQDN(), uref.GetHostFQDN())) {
               // Ok, coordinates match
               return kTRUE;
            }
         }
      }
   }

   // Default is not matching
   return kFALSE;
}

//______________________________________________________________________________
TFile::EFileType TFile::GetType(const char *name, Option_t *option, TString *prefix)
{
   // Resolve the file type as a function of the protocol field in 'name'
   // If defined, the string 'prefix' is added when testing the locality of
   // a 'name' with network-like structure (i.e. root://host//path); if the file
   // is local, on return 'prefix' will contain the actual local path of the file.

   EFileType type = kDefault;

   TPMERegexp re("^(root|xroot).*", "i");
   if (re.Match(name)) {
      //
      // Should be a network file ...
      type = kNet;
      // ... but make sure that is not local or that a remote-like connection
      // is forced. Treat it as local if:
      //    i)  the url points to the localhost, the file will be opened in
      //        readonly mode and the current user has read access;
      //    ii) the specified user is equal to the current user then open local
      //        TFile.
      Bool_t localFile = kFALSE;
      TUrl url(name);
      //
      // Check whether we should try to optimize for local files
      Bool_t forceRemote = gEnv->GetValue("Path.ForceRemote", 0);
      forceRemote = (forceRemote) ? kTRUE : gEnv->GetValue("TFile.ForceRemote", 0);
      TString opts = url.GetOptions();
      if (opts.Contains("remote=1"))
         forceRemote = kTRUE;
      else if (opts.Contains("remote=0"))
         forceRemote = kFALSE;
      if (!forceRemote) {
         // Generic locality test
         localFile = gSystem->IsPathLocal(name);
         if (localFile) {
            // Local path including the prefix
            const char *fname = url.GetFileAndOptions();
            TString lfname;
            if (fname[0] == '/') {
               if (prefix)
                  lfname.Form("%s%s", prefix->Data(), fname);
               else
                  lfname = fname;
            } else if (fname[0] == '~' || fname[0] == '$') {
               lfname = fname;
            } else {
               lfname.Form("%s/%s", gSystem->HomeDirectory(), fname);
            }
            // If option "READ" test existence and access
            TString opt = option;
            Bool_t read = (opt.IsNull() ||
                          !opt.CompareTo("READ", TString::kIgnoreCase)) ? kTRUE : kFALSE;
            if (read) {
               char *fn;
               if ((fn = gSystem->ExpandPathName(TUrl(lfname).GetFile()))) {
                  if (gSystem->AccessPathName(fn, kReadPermission))
                     localFile = kFALSE;
                  delete [] fn;
               }
            }
            // Return full local path if requested (and if the case)
            if (localFile && prefix)
               *prefix = lfname;
         }
      }
      //
      // Adjust the type according to findings
      type = (localFile) ? kLocal : type;
   } else if (TPMERegexp("^(http[s]?|s3http[s]?|[a]?s3|gs|gshttp[s]?){1}:", "i").Match(name)) {
      //
      // Web file
      type = kWeb;
   } else if (!strncmp(name, "file:", 5)) {
      //
      // 'file' protocol
      type = kFile;
   }
   // We are done
   return type;
}

//______________________________________________________________________________
TFile::EAsyncOpenStatus TFile::GetAsyncOpenStatus(const char* name)
{
   // Get status of the async open request related to 'name'.

   // Check the list of pending async opem requests
   if (fgAsyncOpenRequests && (fgAsyncOpenRequests->GetSize() > 0)) {
      TIter nxr(fgAsyncOpenRequests);
      TFileOpenHandle *fh = 0;
      while ((fh = (TFileOpenHandle *)nxr()))
         if (fh->Matches(name))
            return TFile::GetAsyncOpenStatus(fh);
   }

   // Check also the list of files open
   R__LOCKGUARD2(gROOTMutex);
   TSeqCollection *of = gROOT->GetListOfFiles();
   if (of && (of->GetSize() > 0)) {
      TIter nxf(of);
      TFile *f = 0;
      while ((f = (TFile *)nxf()))
         if (f->Matches(name))
            return f->GetAsyncOpenStatus();
   }

   // Default is synchronous mode
   return kAOSNotAsync;
}

//______________________________________________________________________________
TFile::EAsyncOpenStatus TFile::GetAsyncOpenStatus(TFileOpenHandle *handle)
{
   // Get status of the async open request related to 'handle'.

   if (handle && handle->fFile) {
      if (!handle->fFile->IsZombie())
         return handle->fFile->GetAsyncOpenStatus();
      else
         return TFile::kAOSFailure;
   }

   // Default is synchronous mode
   return TFile::kAOSNotAsync;
}

//______________________________________________________________________________
const TUrl *TFile::GetEndpointUrl(const char* name)
{
   // Get final URL for file being opened asynchronously.
   // Returns 0 is the information is not yet available.

   // Check the list of pending async opem requests
   if (fgAsyncOpenRequests && (fgAsyncOpenRequests->GetSize() > 0)) {
      TIter nxr(fgAsyncOpenRequests);
      TFileOpenHandle *fh = 0;
      while ((fh = (TFileOpenHandle *)nxr()))
         if (fh->Matches(name))
            if (fh->fFile)
               return fh->fFile->GetEndpointUrl();
   }

   // Check also the list of files open
   R__LOCKGUARD2(gROOTMutex);
   TSeqCollection *of = gROOT->GetListOfFiles();
   if (of && (of->GetSize() > 0)) {
      TIter nxf(of);
      TFile *f = 0;
      while ((f = (TFile *)nxf()))
         if (f->Matches(name))
            return f->GetEndpointUrl();
   }

   // Information not yet available
   return (const TUrl *)0;
}

//______________________________________________________________________________
void TFile::CpProgress(Long64_t bytesread, Long64_t size, TStopwatch &watch)
{
   // Print file copy progress.

   fprintf(stderr, "[TFile::Cp] Total %.02f MB\t|", (Double_t)size/1048576);

   for (int l = 0; l < 20; l++) {
      if (size > 0) {
         if (l < 20*bytesread/size)
            fprintf(stderr, "=");
         else if (l == 20*bytesread/size)
            fprintf(stderr, ">");
         else if (l > 20*bytesread/size)
            fprintf(stderr, ".");
      } else
         fprintf(stderr, "=");
   }
   // Allow to update the GUI while uploading files
   gSystem->ProcessEvents();
   watch.Stop();
   Double_t lCopy_time = watch.RealTime();
   fprintf(stderr, "| %.02f %% [%.01f MB/s]\r",
           100.0*(size?(bytesread/((float)size)):1), (lCopy_time>0.)?bytesread/lCopy_time/1048576.:0.);
   watch.Continue();
}

//______________________________________________________________________________
Bool_t TFile::Cp(const char *dst, Bool_t progressbar, UInt_t buffersize)
{
   // Allows to copy this file to the dst URL. Returns kTRUE in case of success,
   // kFALSE otherwise.

   Bool_t rmdestiferror = kFALSE;
   TStopwatch watch;
   Bool_t success = kFALSE;

   TUrl dURL(dst, kTRUE);

   TString oopt = "RECREATE";
   TString ourl = dURL.GetUrl();

   // Files will be open in RAW mode
   TString raw = "filetype=raw";

   // Set optimization options for the destination file
   TString opt = dURL.GetOptions();
   if (opt != "") opt += "&";
   opt += raw;

   // AliEn files need to know where the source file is
   if (!strcmp(dURL.GetProtocol(), "alien"))
      opt += TString::Format("&source=%s", GetName());

   dURL.SetOptions(opt);

   char *copybuffer = 0;

   TFile *sfile = this;
   TFile *dfile = 0;

   // "RECREATE" does not work always well with XROOTD
   // namely when some pieces of the path are missing;
   // we force "NEW" in such a case
   if (TFile::GetType(ourl, "") == TFile::kNet) {
      if (gSystem->AccessPathName(ourl)) {
         oopt = "NEW";
         // Force creation of the missing parts of the path
         opt += "&mkpath=1";
         dURL.SetOptions(opt);
      }
   }

   // Open destination file
   if (!(dfile = TFile::Open(dURL.GetUrl(), oopt))) {
      ::Error("TFile::Cp", "cannot open destination file %s", dst);
      goto copyout;
   }

   // Probably we created a new file
   // We have to remove it in case of errors
   rmdestiferror = kTRUE;

   sfile->Seek(0);
   dfile->Seek(0);

   copybuffer = new char[buffersize];
   if (!copybuffer) {
      ::Error("TFile::Cp", "cannot allocate the copy buffer");
      goto copyout;
   }

   Bool_t   readop;
   Bool_t   writeop;
   Long64_t read;
   Long64_t written;
   Long64_t totalread;
   Long64_t filesize;
   Long64_t b00;
   filesize  = sfile->GetSize();
   totalread = 0;
   watch.Start();

   b00 = sfile->GetBytesRead();

   do {
      if (progressbar) CpProgress(totalread, filesize,watch);

      Long64_t b1 = sfile->GetBytesRead() - b00;

      Long64_t readsize;
      if (filesize - b1 > (Long64_t)buffersize) {
         readsize = buffersize;
      } else {
         readsize = filesize - b1;
      }

      if (readsize == 0) break;

      Long64_t b0 = sfile->GetBytesRead();
      sfile->Seek(totalread,TFile::kBeg);
      readop = sfile->ReadBuffer(copybuffer, (Int_t)readsize);
      read   = sfile->GetBytesRead() - b0;
      if ((read <= 0) || readop) {
         ::Error("TFile::Cp", "cannot read from source file %s. readsize=%lld read=%lld readop=%d",
                              sfile->GetName(), readsize, read, readop);
         goto copyout;
      }

      Long64_t w0 = dfile->GetBytesWritten();
      writeop = dfile->WriteBuffer(copybuffer, (Int_t)read);
      written = dfile->GetBytesWritten() - w0;
      if ((written != read) || writeop) {
         ::Error("TFile::Cp", "cannot write %lld bytes to destination file %s", read, dst);
         goto copyout;
      }
      totalread += read;
   } while (read == (Long64_t)buffersize);

   if (progressbar) {
      CpProgress(totalread, filesize,watch);
      fprintf(stderr, "\n");
   }

   success = kTRUE;

copyout:
   if (dfile) dfile->Close();

   if (dfile) delete dfile;
   if (copybuffer) delete[] copybuffer;

   if (rmdestiferror && (success != kTRUE))
      gSystem->Unlink(dst);

   watch.Stop();
   watch.Reset();

   return success;
}

//______________________________________________________________________________
Bool_t TFile::Cp(const char *src, const char *dst, Bool_t progressbar,
                 UInt_t buffersize)
{
   // Allows to copy file from src to dst URL. Returns kTRUE in case of success,
   // kFALSE otherwise.

   TUrl sURL(src, kTRUE);

   // Files will be open in RAW mode
   TString raw = "filetype=raw";

   // Set optimization options for the source file
   TString opt = sURL.GetOptions();
   if (opt != "") opt += "&";
   opt += raw;
   // Netx-related options:
   //    cachesz = 4*buffersize     -> 4 buffers as peak mem usage
   //    readaheadsz = 2*buffersize -> Keep at max 4*buffersize bytes outstanding when reading
   //    rmpolicy = 1               -> Remove from the cache the blk with the least offset
   opt += TString::Format("&cachesz=%d&readaheadsz=%d&rmpolicy=1", 4*buffersize, 2*buffersize);
   sURL.SetOptions(opt);

   TFile *sfile = 0;

   Bool_t success = kFALSE;

   // Open source file
   if (!(sfile = TFile::Open(sURL.GetUrl(), "READ"))) {
      ::Error("TFile::Cp", "cannot open source file %s", src);
   } else {
      success = sfile->Cp(dst, progressbar, buffersize);
   }

   if (sfile) sfile->Close();
   if (sfile) delete sfile;

   return success;
}

//______________________________________________________________________________
//The next statement is not active anymore on Linux.
//Using posix_fadvise introduces a performance penalty (10 %) on optimized files
//and in addition it destroys the information of TTreePerfStats
#if defined(R__neverLINUX) && !defined(R__WINGCC)
Bool_t TFile::ReadBufferAsync(Long64_t offset, Int_t len)
{
   // Read specified byte range asynchronously. Actually we tell the kernel
   // which blocks we are going to read so it can start loading these blocks
   // in the buffer cache.

   // Shortcut to avoid having to implement dummy ReadBufferAsync() in all
   // I/O plugins. Override ReadBufferAsync() in plugins if async is supported.
   if (IsA() != TFile::Class())
      return kTRUE;

   int advice = POSIX_FADV_WILLNEED;
   if (len == 0) {
      // according POSIX spec if len is zero, all data following offset
      // is specified. Nevertheless ROOT uses zero to probe readahead
      // capadilites.
      advice = POSIX_FADV_NORMAL;
   }
   Double_t start = 0;
   if (gPerfStats != 0) start = TTimeStamp();
#if defined(R__SEEK64)
   Int_t result = posix_fadvise64(fD, offset, len, advice);
#else
   Int_t result = posix_fadvise(fD, offset, len, advice);
#endif
   if (gPerfStats != 0) {
      gPerfStats->FileReadEvent(this, len, start);
   }
   return (result != 0);
}
#else
Bool_t TFile::ReadBufferAsync(Long64_t, Int_t)
{
   // Not supported yet on non Linux systems.

   return kTRUE;
}
#endif

//______________________________________________________________________________
Int_t TFile::GetBytesToPrefetch() const
{
   // Max number of bytes to prefetch. By default this is 75% of the
   // read cache size. But specific TFile implementations may need to change it

   TFileCacheRead *cr = 0;
   if ((cr = GetCacheRead())) {
      Int_t bytes = cr->GetBufferSize() / 4 * 3;
      return ((bytes < 0) ? 0 : bytes);
   }
   return 0;
}
 TFile.cxx:1
 TFile.cxx:2
 TFile.cxx:3
 TFile.cxx:4
 TFile.cxx:5
 TFile.cxx:6
 TFile.cxx:7
 TFile.cxx:8
 TFile.cxx:9
 TFile.cxx:10
 TFile.cxx:11
 TFile.cxx:12
 TFile.cxx:13
 TFile.cxx:14
 TFile.cxx:15
 TFile.cxx:16
 TFile.cxx:17
 TFile.cxx:18
 TFile.cxx:19
 TFile.cxx:20
 TFile.cxx:21
 TFile.cxx:22
 TFile.cxx:23
 TFile.cxx:24
 TFile.cxx:25
 TFile.cxx:26
 TFile.cxx:27
 TFile.cxx:28
 TFile.cxx:29
 TFile.cxx:30
 TFile.cxx:31
 TFile.cxx:32
 TFile.cxx:33
 TFile.cxx:34
 TFile.cxx:35
 TFile.cxx:36
 TFile.cxx:37
 TFile.cxx:38
 TFile.cxx:39
 TFile.cxx:40
 TFile.cxx:41
 TFile.cxx:42
 TFile.cxx:43
 TFile.cxx:44
 TFile.cxx:45
 TFile.cxx:46
 TFile.cxx:47
 TFile.cxx:48
 TFile.cxx:49
 TFile.cxx:50
 TFile.cxx:51
 TFile.cxx:52
 TFile.cxx:53
 TFile.cxx:54
 TFile.cxx:55
 TFile.cxx:56
 TFile.cxx:57
 TFile.cxx:58
 TFile.cxx:59
 TFile.cxx:60
 TFile.cxx:61
 TFile.cxx:62
 TFile.cxx:63
 TFile.cxx:64
 TFile.cxx:65
 TFile.cxx:66
 TFile.cxx:67
 TFile.cxx:68
 TFile.cxx:69
 TFile.cxx:70
 TFile.cxx:71
 TFile.cxx:72
 TFile.cxx:73
 TFile.cxx:74
 TFile.cxx:75
 TFile.cxx:76
 TFile.cxx:77
 TFile.cxx:78
 TFile.cxx:79
 TFile.cxx:80
 TFile.cxx:81
 TFile.cxx:82
 TFile.cxx:83
 TFile.cxx:84
 TFile.cxx:85
 TFile.cxx:86
 TFile.cxx:87
 TFile.cxx:88
 TFile.cxx:89
 TFile.cxx:90
 TFile.cxx:91
 TFile.cxx:92
 TFile.cxx:93
 TFile.cxx:94
 TFile.cxx:95
 TFile.cxx:96
 TFile.cxx:97
 TFile.cxx:98
 TFile.cxx:99
 TFile.cxx:100
 TFile.cxx:101
 TFile.cxx:102
 TFile.cxx:103
 TFile.cxx:104
 TFile.cxx:105
 TFile.cxx:106
 TFile.cxx:107
 TFile.cxx:108
 TFile.cxx:109
 TFile.cxx:110
 TFile.cxx:111
 TFile.cxx:112
 TFile.cxx:113
 TFile.cxx:114
 TFile.cxx:115
 TFile.cxx:116
 TFile.cxx:117
 TFile.cxx:118
 TFile.cxx:119
 TFile.cxx:120
 TFile.cxx:121
 TFile.cxx:122
 TFile.cxx:123
 TFile.cxx:124
 TFile.cxx:125
 TFile.cxx:126
 TFile.cxx:127
 TFile.cxx:128
 TFile.cxx:129
 TFile.cxx:130
 TFile.cxx:131
 TFile.cxx:132
 TFile.cxx:133
 TFile.cxx:134
 TFile.cxx:135
 TFile.cxx:136
 TFile.cxx:137
 TFile.cxx:138
 TFile.cxx:139
 TFile.cxx:140
 TFile.cxx:141
 TFile.cxx:142
 TFile.cxx:143
 TFile.cxx:144
 TFile.cxx:145
 TFile.cxx:146
 TFile.cxx:147
 TFile.cxx:148
 TFile.cxx:149
 TFile.cxx:150
 TFile.cxx:151
 TFile.cxx:152
 TFile.cxx:153
 TFile.cxx:154
 TFile.cxx:155
 TFile.cxx:156
 TFile.cxx:157
 TFile.cxx:158
 TFile.cxx:159
 TFile.cxx:160
 TFile.cxx:161
 TFile.cxx:162
 TFile.cxx:163
 TFile.cxx:164
 TFile.cxx:165
 TFile.cxx:166
 TFile.cxx:167
 TFile.cxx:168
 TFile.cxx:169
 TFile.cxx:170
 TFile.cxx:171
 TFile.cxx:172
 TFile.cxx:173
 TFile.cxx:174
 TFile.cxx:175
 TFile.cxx:176
 TFile.cxx:177
 TFile.cxx:178
 TFile.cxx:179
 TFile.cxx:180
 TFile.cxx:181
 TFile.cxx:182
 TFile.cxx:183
 TFile.cxx:184
 TFile.cxx:185
 TFile.cxx:186
 TFile.cxx:187
 TFile.cxx:188
 TFile.cxx:189
 TFile.cxx:190
 TFile.cxx:191
 TFile.cxx:192
 TFile.cxx:193
 TFile.cxx:194
 TFile.cxx:195
 TFile.cxx:196
 TFile.cxx:197
 TFile.cxx:198
 TFile.cxx:199
 TFile.cxx:200
 TFile.cxx:201
 TFile.cxx:202
 TFile.cxx:203
 TFile.cxx:204
 TFile.cxx:205
 TFile.cxx:206
 TFile.cxx:207
 TFile.cxx:208
 TFile.cxx:209
 TFile.cxx:210
 TFile.cxx:211
 TFile.cxx:212
 TFile.cxx:213
 TFile.cxx:214
 TFile.cxx:215
 TFile.cxx:216
 TFile.cxx:217
 TFile.cxx:218
 TFile.cxx:219
 TFile.cxx:220
 TFile.cxx:221
 TFile.cxx:222
 TFile.cxx:223
 TFile.cxx:224
 TFile.cxx:225
 TFile.cxx:226
 TFile.cxx:227
 TFile.cxx:228
 TFile.cxx:229
 TFile.cxx:230
 TFile.cxx:231
 TFile.cxx:232
 TFile.cxx:233
 TFile.cxx:234
 TFile.cxx:235
 TFile.cxx:236
 TFile.cxx:237
 TFile.cxx:238
 TFile.cxx:239
 TFile.cxx:240
 TFile.cxx:241
 TFile.cxx:242
 TFile.cxx:243
 TFile.cxx:244
 TFile.cxx:245
 TFile.cxx:246
 TFile.cxx:247
 TFile.cxx:248
 TFile.cxx:249
 TFile.cxx:250
 TFile.cxx:251
 TFile.cxx:252
 TFile.cxx:253
 TFile.cxx:254
 TFile.cxx:255
 TFile.cxx:256
 TFile.cxx:257
 TFile.cxx:258
 TFile.cxx:259
 TFile.cxx:260
 TFile.cxx:261
 TFile.cxx:262
 TFile.cxx:263
 TFile.cxx:264
 TFile.cxx:265
 TFile.cxx:266
 TFile.cxx:267
 TFile.cxx:268
 TFile.cxx:269
 TFile.cxx:270
 TFile.cxx:271
 TFile.cxx:272
 TFile.cxx:273
 TFile.cxx:274
 TFile.cxx:275
 TFile.cxx:276
 TFile.cxx:277
 TFile.cxx:278
 TFile.cxx:279
 TFile.cxx:280
 TFile.cxx:281
 TFile.cxx:282
 TFile.cxx:283
 TFile.cxx:284
 TFile.cxx:285
 TFile.cxx:286
 TFile.cxx:287
 TFile.cxx:288
 TFile.cxx:289
 TFile.cxx:290
 TFile.cxx:291
 TFile.cxx:292
 TFile.cxx:293
 TFile.cxx:294
 TFile.cxx:295
 TFile.cxx:296
 TFile.cxx:297
 TFile.cxx:298
 TFile.cxx:299
 TFile.cxx:300
 TFile.cxx:301
 TFile.cxx:302
 TFile.cxx:303
 TFile.cxx:304
 TFile.cxx:305
 TFile.cxx:306
 TFile.cxx:307
 TFile.cxx:308
 TFile.cxx:309
 TFile.cxx:310
 TFile.cxx:311
 TFile.cxx:312
 TFile.cxx:313
 TFile.cxx:314
 TFile.cxx:315
 TFile.cxx:316
 TFile.cxx:317
 TFile.cxx:318
 TFile.cxx:319
 TFile.cxx:320
 TFile.cxx:321
 TFile.cxx:322
 TFile.cxx:323
 TFile.cxx:324
 TFile.cxx:325
 TFile.cxx:326
 TFile.cxx:327
 TFile.cxx:328
 TFile.cxx:329
 TFile.cxx:330
 TFile.cxx:331
 TFile.cxx:332
 TFile.cxx:333
 TFile.cxx:334
 TFile.cxx:335
 TFile.cxx:336
 TFile.cxx:337
 TFile.cxx:338
 TFile.cxx:339
 TFile.cxx:340
 TFile.cxx:341
 TFile.cxx:342
 TFile.cxx:343
 TFile.cxx:344
 TFile.cxx:345
 TFile.cxx:346
 TFile.cxx:347
 TFile.cxx:348
 TFile.cxx:349
 TFile.cxx:350
 TFile.cxx:351
 TFile.cxx:352
 TFile.cxx:353
 TFile.cxx:354
 TFile.cxx:355
 TFile.cxx:356
 TFile.cxx:357
 TFile.cxx:358
 TFile.cxx:359
 TFile.cxx:360
 TFile.cxx:361
 TFile.cxx:362
 TFile.cxx:363
 TFile.cxx:364
 TFile.cxx:365
 TFile.cxx:366
 TFile.cxx:367
 TFile.cxx:368
 TFile.cxx:369
 TFile.cxx:370
 TFile.cxx:371
 TFile.cxx:372
 TFile.cxx:373
 TFile.cxx:374
 TFile.cxx:375
 TFile.cxx:376
 TFile.cxx:377
 TFile.cxx:378
 TFile.cxx:379
 TFile.cxx:380
 TFile.cxx:381
 TFile.cxx:382
 TFile.cxx:383
 TFile.cxx:384
 TFile.cxx:385
 TFile.cxx:386
 TFile.cxx:387
 TFile.cxx:388
 TFile.cxx:389
 TFile.cxx:390
 TFile.cxx:391
 TFile.cxx:392
 TFile.cxx:393
 TFile.cxx:394
 TFile.cxx:395
 TFile.cxx:396
 TFile.cxx:397
 TFile.cxx:398
 TFile.cxx:399
 TFile.cxx:400
 TFile.cxx:401
 TFile.cxx:402
 TFile.cxx:403
 TFile.cxx:404
 TFile.cxx:405
 TFile.cxx:406
 TFile.cxx:407
 TFile.cxx:408
 TFile.cxx:409
 TFile.cxx:410
 TFile.cxx:411
 TFile.cxx:412
 TFile.cxx:413
 TFile.cxx:414
 TFile.cxx:415
 TFile.cxx:416
 TFile.cxx:417
 TFile.cxx:418
 TFile.cxx:419
 TFile.cxx:420
 TFile.cxx:421
 TFile.cxx:422
 TFile.cxx:423
 TFile.cxx:424
 TFile.cxx:425
 TFile.cxx:426
 TFile.cxx:427
 TFile.cxx:428
 TFile.cxx:429
 TFile.cxx:430
 TFile.cxx:431
 TFile.cxx:432
 TFile.cxx:433
 TFile.cxx:434
 TFile.cxx:435
 TFile.cxx:436
 TFile.cxx:437
 TFile.cxx:438
 TFile.cxx:439
 TFile.cxx:440
 TFile.cxx:441
 TFile.cxx:442
 TFile.cxx:443
 TFile.cxx:444
 TFile.cxx:445
 TFile.cxx:446
 TFile.cxx:447
 TFile.cxx:448
 TFile.cxx:449
 TFile.cxx:450
 TFile.cxx:451
 TFile.cxx:452
 TFile.cxx:453
 TFile.cxx:454
 TFile.cxx:455
 TFile.cxx:456
 TFile.cxx:457
 TFile.cxx:458
 TFile.cxx:459
 TFile.cxx:460
 TFile.cxx:461
 TFile.cxx:462
 TFile.cxx:463
 TFile.cxx:464
 TFile.cxx:465
 TFile.cxx:466
 TFile.cxx:467
 TFile.cxx:468
 TFile.cxx:469
 TFile.cxx:470
 TFile.cxx:471
 TFile.cxx:472
 TFile.cxx:473
 TFile.cxx:474
 TFile.cxx:475
 TFile.cxx:476
 TFile.cxx:477
 TFile.cxx:478
 TFile.cxx:479
 TFile.cxx:480
 TFile.cxx:481
 TFile.cxx:482
 TFile.cxx:483
 TFile.cxx:484
 TFile.cxx:485
 TFile.cxx:486
 TFile.cxx:487
 TFile.cxx:488
 TFile.cxx:489
 TFile.cxx:490
 TFile.cxx:491
 TFile.cxx:492
 TFile.cxx:493
 TFile.cxx:494
 TFile.cxx:495
 TFile.cxx:496
 TFile.cxx:497
 TFile.cxx:498
 TFile.cxx:499
 TFile.cxx:500
 TFile.cxx:501
 TFile.cxx:502
 TFile.cxx:503
 TFile.cxx:504
 TFile.cxx:505
 TFile.cxx:506
 TFile.cxx:507
 TFile.cxx:508
 TFile.cxx:509
 TFile.cxx:510
 TFile.cxx:511
 TFile.cxx:512
 TFile.cxx:513
 TFile.cxx:514
 TFile.cxx:515
 TFile.cxx:516
 TFile.cxx:517
 TFile.cxx:518
 TFile.cxx:519
 TFile.cxx:520
 TFile.cxx:521
 TFile.cxx:522
 TFile.cxx:523
 TFile.cxx:524
 TFile.cxx:525
 TFile.cxx:526
 TFile.cxx:527
 TFile.cxx:528
 TFile.cxx:529
 TFile.cxx:530
 TFile.cxx:531
 TFile.cxx:532
 TFile.cxx:533
 TFile.cxx:534
 TFile.cxx:535
 TFile.cxx:536
 TFile.cxx:537
 TFile.cxx:538
 TFile.cxx:539
 TFile.cxx:540
 TFile.cxx:541
 TFile.cxx:542
 TFile.cxx:543
 TFile.cxx:544
 TFile.cxx:545
 TFile.cxx:546
 TFile.cxx:547
 TFile.cxx:548
 TFile.cxx:549
 TFile.cxx:550
 TFile.cxx:551
 TFile.cxx:552
 TFile.cxx:553
 TFile.cxx:554
 TFile.cxx:555
 TFile.cxx:556
 TFile.cxx:557
 TFile.cxx:558
 TFile.cxx:559
 TFile.cxx:560
 TFile.cxx:561
 TFile.cxx:562
 TFile.cxx:563
 TFile.cxx:564
 TFile.cxx:565
 TFile.cxx:566
 TFile.cxx:567
 TFile.cxx:568
 TFile.cxx:569
 TFile.cxx:570
 TFile.cxx:571
 TFile.cxx:572
 TFile.cxx:573
 TFile.cxx:574
 TFile.cxx:575
 TFile.cxx:576
 TFile.cxx:577
 TFile.cxx:578
 TFile.cxx:579
 TFile.cxx:580
 TFile.cxx:581
 TFile.cxx:582
 TFile.cxx:583
 TFile.cxx:584
 TFile.cxx:585
 TFile.cxx:586
 TFile.cxx:587
 TFile.cxx:588
 TFile.cxx:589
 TFile.cxx:590
 TFile.cxx:591
 TFile.cxx:592
 TFile.cxx:593
 TFile.cxx:594
 TFile.cxx:595
 TFile.cxx:596
 TFile.cxx:597
 TFile.cxx:598
 TFile.cxx:599
 TFile.cxx:600
 TFile.cxx:601
 TFile.cxx:602
 TFile.cxx:603
 TFile.cxx:604
 TFile.cxx:605
 TFile.cxx:606
 TFile.cxx:607
 TFile.cxx:608
 TFile.cxx:609
 TFile.cxx:610
 TFile.cxx:611
 TFile.cxx:612
 TFile.cxx:613
 TFile.cxx:614
 TFile.cxx:615
 TFile.cxx:616
 TFile.cxx:617
 TFile.cxx:618
 TFile.cxx:619
 TFile.cxx:620
 TFile.cxx:621
 TFile.cxx:622
 TFile.cxx:623
 TFile.cxx:624
 TFile.cxx:625
 TFile.cxx:626
 TFile.cxx:627
 TFile.cxx:628
 TFile.cxx:629
 TFile.cxx:630
 TFile.cxx:631
 TFile.cxx:632
 TFile.cxx:633
 TFile.cxx:634
 TFile.cxx:635
 TFile.cxx:636
 TFile.cxx:637
 TFile.cxx:638
 TFile.cxx:639
 TFile.cxx:640
 TFile.cxx:641
 TFile.cxx:642
 TFile.cxx:643
 TFile.cxx:644
 TFile.cxx:645
 TFile.cxx:646
 TFile.cxx:647
 TFile.cxx:648
 TFile.cxx:649
 TFile.cxx:650
 TFile.cxx:651
 TFile.cxx:652
 TFile.cxx:653
 TFile.cxx:654
 TFile.cxx:655
 TFile.cxx:656
 TFile.cxx:657
 TFile.cxx:658
 TFile.cxx:659
 TFile.cxx:660
 TFile.cxx:661
 TFile.cxx:662
 TFile.cxx:663
 TFile.cxx:664
 TFile.cxx:665
 TFile.cxx:666
 TFile.cxx:667
 TFile.cxx:668
 TFile.cxx:669
 TFile.cxx:670
 TFile.cxx:671
 TFile.cxx:672
 TFile.cxx:673
 TFile.cxx:674
 TFile.cxx:675
 TFile.cxx:676
 TFile.cxx:677
 TFile.cxx:678
 TFile.cxx:679
 TFile.cxx:680
 TFile.cxx:681
 TFile.cxx:682
 TFile.cxx:683
 TFile.cxx:684
 TFile.cxx:685
 TFile.cxx:686
 TFile.cxx:687
 TFile.cxx:688
 TFile.cxx:689
 TFile.cxx:690
 TFile.cxx:691
 TFile.cxx:692
 TFile.cxx:693
 TFile.cxx:694
 TFile.cxx:695
 TFile.cxx:696
 TFile.cxx:697
 TFile.cxx:698
 TFile.cxx:699
 TFile.cxx:700
 TFile.cxx:701
 TFile.cxx:702
 TFile.cxx:703
 TFile.cxx:704
 TFile.cxx:705
 TFile.cxx:706
 TFile.cxx:707
 TFile.cxx:708
 TFile.cxx:709
 TFile.cxx:710
 TFile.cxx:711
 TFile.cxx:712
 TFile.cxx:713
 TFile.cxx:714
 TFile.cxx:715
 TFile.cxx:716
 TFile.cxx:717
 TFile.cxx:718
 TFile.cxx:719
 TFile.cxx:720
 TFile.cxx:721
 TFile.cxx:722
 TFile.cxx:723
 TFile.cxx:724
 TFile.cxx:725
 TFile.cxx:726
 TFile.cxx:727
 TFile.cxx:728
 TFile.cxx:729
 TFile.cxx:730
 TFile.cxx:731
 TFile.cxx:732
 TFile.cxx:733
 TFile.cxx:734
 TFile.cxx:735
 TFile.cxx:736
 TFile.cxx:737
 TFile.cxx:738
 TFile.cxx:739
 TFile.cxx:740
 TFile.cxx:741
 TFile.cxx:742
 TFile.cxx:743
 TFile.cxx:744
 TFile.cxx:745
 TFile.cxx:746
 TFile.cxx:747
 TFile.cxx:748
 TFile.cxx:749
 TFile.cxx:750
 TFile.cxx:751
 TFile.cxx:752
 TFile.cxx:753
 TFile.cxx:754
 TFile.cxx:755
 TFile.cxx:756
 TFile.cxx:757
 TFile.cxx:758
 TFile.cxx:759
 TFile.cxx:760
 TFile.cxx:761
 TFile.cxx:762
 TFile.cxx:763
 TFile.cxx:764
 TFile.cxx:765
 TFile.cxx:766
 TFile.cxx:767
 TFile.cxx:768
 TFile.cxx:769
 TFile.cxx:770
 TFile.cxx:771
 TFile.cxx:772
 TFile.cxx:773
 TFile.cxx:774
 TFile.cxx:775
 TFile.cxx:776
 TFile.cxx:777
 TFile.cxx:778
 TFile.cxx:779
 TFile.cxx:780
 TFile.cxx:781
 TFile.cxx:782
 TFile.cxx:783
 TFile.cxx:784
 TFile.cxx:785
 TFile.cxx:786
 TFile.cxx:787
 TFile.cxx:788
 TFile.cxx:789
 TFile.cxx:790
 TFile.cxx:791
 TFile.cxx:792
 TFile.cxx:793
 TFile.cxx:794
 TFile.cxx:795
 TFile.cxx:796
 TFile.cxx:797
 TFile.cxx:798
 TFile.cxx:799
 TFile.cxx:800
 TFile.cxx:801
 TFile.cxx:802
 TFile.cxx:803
 TFile.cxx:804
 TFile.cxx:805
 TFile.cxx:806
 TFile.cxx:807
 TFile.cxx:808
 TFile.cxx:809
 TFile.cxx:810
 TFile.cxx:811
 TFile.cxx:812
 TFile.cxx:813
 TFile.cxx:814
 TFile.cxx:815
 TFile.cxx:816
 TFile.cxx:817
 TFile.cxx:818
 TFile.cxx:819
 TFile.cxx:820
 TFile.cxx:821
 TFile.cxx:822
 TFile.cxx:823
 TFile.cxx:824
 TFile.cxx:825
 TFile.cxx:826
 TFile.cxx:827
 TFile.cxx:828
 TFile.cxx:829
 TFile.cxx:830
 TFile.cxx:831
 TFile.cxx:832
 TFile.cxx:833
 TFile.cxx:834
 TFile.cxx:835
 TFile.cxx:836
 TFile.cxx:837
 TFile.cxx:838
 TFile.cxx:839
 TFile.cxx:840
 TFile.cxx:841
 TFile.cxx:842
 TFile.cxx:843
 TFile.cxx:844
 TFile.cxx:845
 TFile.cxx:846
 TFile.cxx:847
 TFile.cxx:848
 TFile.cxx:849
 TFile.cxx:850
 TFile.cxx:851
 TFile.cxx:852
 TFile.cxx:853
 TFile.cxx:854
 TFile.cxx:855
 TFile.cxx:856
 TFile.cxx:857
 TFile.cxx:858
 TFile.cxx:859
 TFile.cxx:860
 TFile.cxx:861
 TFile.cxx:862
 TFile.cxx:863
 TFile.cxx:864
 TFile.cxx:865
 TFile.cxx:866
 TFile.cxx:867
 TFile.cxx:868
 TFile.cxx:869
 TFile.cxx:870
 TFile.cxx:871
 TFile.cxx:872
 TFile.cxx:873
 TFile.cxx:874
 TFile.cxx:875
 TFile.cxx:876
 TFile.cxx:877
 TFile.cxx:878
 TFile.cxx:879
 TFile.cxx:880
 TFile.cxx:881
 TFile.cxx:882
 TFile.cxx:883
 TFile.cxx:884
 TFile.cxx:885
 TFile.cxx:886
 TFile.cxx:887
 TFile.cxx:888
 TFile.cxx:889
 TFile.cxx:890
 TFile.cxx:891
 TFile.cxx:892
 TFile.cxx:893
 TFile.cxx:894
 TFile.cxx:895
 TFile.cxx:896
 TFile.cxx:897
 TFile.cxx:898
 TFile.cxx:899
 TFile.cxx:900
 TFile.cxx:901
 TFile.cxx:902
 TFile.cxx:903
 TFile.cxx:904
 TFile.cxx:905
 TFile.cxx:906
 TFile.cxx:907
 TFile.cxx:908
 TFile.cxx:909
 TFile.cxx:910
 TFile.cxx:911
 TFile.cxx:912
 TFile.cxx:913
 TFile.cxx:914
 TFile.cxx:915
 TFile.cxx:916
 TFile.cxx:917
 TFile.cxx:918
 TFile.cxx:919
 TFile.cxx:920
 TFile.cxx:921
 TFile.cxx:922
 TFile.cxx:923
 TFile.cxx:924
 TFile.cxx:925
 TFile.cxx:926
 TFile.cxx:927
 TFile.cxx:928
 TFile.cxx:929
 TFile.cxx:930
 TFile.cxx:931
 TFile.cxx:932
 TFile.cxx:933
 TFile.cxx:934
 TFile.cxx:935
 TFile.cxx:936
 TFile.cxx:937
 TFile.cxx:938
 TFile.cxx:939
 TFile.cxx:940
 TFile.cxx:941
 TFile.cxx:942
 TFile.cxx:943
 TFile.cxx:944
 TFile.cxx:945
 TFile.cxx:946
 TFile.cxx:947
 TFile.cxx:948
 TFile.cxx:949
 TFile.cxx:950
 TFile.cxx:951
 TFile.cxx:952
 TFile.cxx:953
 TFile.cxx:954
 TFile.cxx:955
 TFile.cxx:956
 TFile.cxx:957
 TFile.cxx:958
 TFile.cxx:959
 TFile.cxx:960
 TFile.cxx:961
 TFile.cxx:962
 TFile.cxx:963
 TFile.cxx:964
 TFile.cxx:965
 TFile.cxx:966
 TFile.cxx:967
 TFile.cxx:968
 TFile.cxx:969
 TFile.cxx:970
 TFile.cxx:971
 TFile.cxx:972
 TFile.cxx:973
 TFile.cxx:974
 TFile.cxx:975
 TFile.cxx:976
 TFile.cxx:977
 TFile.cxx:978
 TFile.cxx:979
 TFile.cxx:980
 TFile.cxx:981
 TFile.cxx:982
 TFile.cxx:983
 TFile.cxx:984
 TFile.cxx:985
 TFile.cxx:986
 TFile.cxx:987
 TFile.cxx:988
 TFile.cxx:989
 TFile.cxx:990
 TFile.cxx:991
 TFile.cxx:992
 TFile.cxx:993
 TFile.cxx:994
 TFile.cxx:995
 TFile.cxx:996
 TFile.cxx:997
 TFile.cxx:998
 TFile.cxx:999
 TFile.cxx:1000
 TFile.cxx:1001
 TFile.cxx:1002
 TFile.cxx:1003
 TFile.cxx:1004
 TFile.cxx:1005
 TFile.cxx:1006
 TFile.cxx:1007
 TFile.cxx:1008
 TFile.cxx:1009
 TFile.cxx:1010
 TFile.cxx:1011
 TFile.cxx:1012
 TFile.cxx:1013
 TFile.cxx:1014
 TFile.cxx:1015
 TFile.cxx:1016
 TFile.cxx:1017
 TFile.cxx:1018
 TFile.cxx:1019
 TFile.cxx:1020
 TFile.cxx:1021
 TFile.cxx:1022
 TFile.cxx:1023
 TFile.cxx:1024
 TFile.cxx:1025
 TFile.cxx:1026
 TFile.cxx:1027
 TFile.cxx:1028
 TFile.cxx:1029
 TFile.cxx:1030
 TFile.cxx:1031
 TFile.cxx:1032
 TFile.cxx:1033
 TFile.cxx:1034
 TFile.cxx:1035
 TFile.cxx:1036
 TFile.cxx:1037
 TFile.cxx:1038
 TFile.cxx:1039
 TFile.cxx:1040
 TFile.cxx:1041
 TFile.cxx:1042
 TFile.cxx:1043
 TFile.cxx:1044
 TFile.cxx:1045
 TFile.cxx:1046
 TFile.cxx:1047
 TFile.cxx:1048
 TFile.cxx:1049
 TFile.cxx:1050
 TFile.cxx:1051
 TFile.cxx:1052
 TFile.cxx:1053
 TFile.cxx:1054
 TFile.cxx:1055
 TFile.cxx:1056
 TFile.cxx:1057
 TFile.cxx:1058
 TFile.cxx:1059
 TFile.cxx:1060
 TFile.cxx:1061
 TFile.cxx:1062
 TFile.cxx:1063
 TFile.cxx:1064
 TFile.cxx:1065
 TFile.cxx:1066
 TFile.cxx:1067
 TFile.cxx:1068
 TFile.cxx:1069
 TFile.cxx:1070
 TFile.cxx:1071
 TFile.cxx:1072
 TFile.cxx:1073
 TFile.cxx:1074
 TFile.cxx:1075
 TFile.cxx:1076
 TFile.cxx:1077
 TFile.cxx:1078
 TFile.cxx:1079
 TFile.cxx:1080
 TFile.cxx:1081
 TFile.cxx:1082
 TFile.cxx:1083
 TFile.cxx:1084
 TFile.cxx:1085
 TFile.cxx:1086
 TFile.cxx:1087
 TFile.cxx:1088
 TFile.cxx:1089
 TFile.cxx:1090
 TFile.cxx:1091
 TFile.cxx:1092
 TFile.cxx:1093
 TFile.cxx:1094
 TFile.cxx:1095
 TFile.cxx:1096
 TFile.cxx:1097
 TFile.cxx:1098
 TFile.cxx:1099
 TFile.cxx:1100
 TFile.cxx:1101
 TFile.cxx:1102
 TFile.cxx:1103
 TFile.cxx:1104
 TFile.cxx:1105
 TFile.cxx:1106
 TFile.cxx:1107
 TFile.cxx:1108
 TFile.cxx:1109
 TFile.cxx:1110
 TFile.cxx:1111
 TFile.cxx:1112
 TFile.cxx:1113
 TFile.cxx:1114
 TFile.cxx:1115
 TFile.cxx:1116
 TFile.cxx:1117
 TFile.cxx:1118
 TFile.cxx:1119
 TFile.cxx:1120
 TFile.cxx:1121
 TFile.cxx:1122
 TFile.cxx:1123
 TFile.cxx:1124
 TFile.cxx:1125
 TFile.cxx:1126
 TFile.cxx:1127
 TFile.cxx:1128
 TFile.cxx:1129
 TFile.cxx:1130
 TFile.cxx:1131
 TFile.cxx:1132
 TFile.cxx:1133
 TFile.cxx:1134
 TFile.cxx:1135
 TFile.cxx:1136
 TFile.cxx:1137
 TFile.cxx:1138
 TFile.cxx:1139
 TFile.cxx:1140
 TFile.cxx:1141
 TFile.cxx:1142
 TFile.cxx:1143
 TFile.cxx:1144
 TFile.cxx:1145
 TFile.cxx:1146
 TFile.cxx:1147
 TFile.cxx:1148
 TFile.cxx:1149
 TFile.cxx:1150
 TFile.cxx:1151
 TFile.cxx:1152
 TFile.cxx:1153
 TFile.cxx:1154
 TFile.cxx:1155
 TFile.cxx:1156
 TFile.cxx:1157
 TFile.cxx:1158
 TFile.cxx:1159
 TFile.cxx:1160
 TFile.cxx:1161
 TFile.cxx:1162
 TFile.cxx:1163
 TFile.cxx:1164
 TFile.cxx:1165
 TFile.cxx:1166
 TFile.cxx:1167
 TFile.cxx:1168
 TFile.cxx:1169
 TFile.cxx:1170
 TFile.cxx:1171
 TFile.cxx:1172
 TFile.cxx:1173
 TFile.cxx:1174
 TFile.cxx:1175
 TFile.cxx:1176
 TFile.cxx:1177
 TFile.cxx:1178
 TFile.cxx:1179
 TFile.cxx:1180
 TFile.cxx:1181
 TFile.cxx:1182
 TFile.cxx:1183
 TFile.cxx:1184
 TFile.cxx:1185
 TFile.cxx:1186
 TFile.cxx:1187
 TFile.cxx:1188
 TFile.cxx:1189
 TFile.cxx:1190
 TFile.cxx:1191
 TFile.cxx:1192
 TFile.cxx:1193
 TFile.cxx:1194
 TFile.cxx:1195
 TFile.cxx:1196
 TFile.cxx:1197
 TFile.cxx:1198
 TFile.cxx:1199
 TFile.cxx:1200
 TFile.cxx:1201
 TFile.cxx:1202
 TFile.cxx:1203
 TFile.cxx:1204
 TFile.cxx:1205
 TFile.cxx:1206
 TFile.cxx:1207
 TFile.cxx:1208
 TFile.cxx:1209
 TFile.cxx:1210
 TFile.cxx:1211
 TFile.cxx:1212
 TFile.cxx:1213
 TFile.cxx:1214
 TFile.cxx:1215
 TFile.cxx:1216
 TFile.cxx:1217
 TFile.cxx:1218
 TFile.cxx:1219
 TFile.cxx:1220
 TFile.cxx:1221
 TFile.cxx:1222
 TFile.cxx:1223
 TFile.cxx:1224
 TFile.cxx:1225
 TFile.cxx:1226
 TFile.cxx:1227
 TFile.cxx:1228
 TFile.cxx:1229
 TFile.cxx:1230
 TFile.cxx:1231
 TFile.cxx:1232
 TFile.cxx:1233
 TFile.cxx:1234
 TFile.cxx:1235
 TFile.cxx:1236
 TFile.cxx:1237
 TFile.cxx:1238
 TFile.cxx:1239
 TFile.cxx:1240
 TFile.cxx:1241
 TFile.cxx:1242
 TFile.cxx:1243
 TFile.cxx:1244
 TFile.cxx:1245
 TFile.cxx:1246
 TFile.cxx:1247
 TFile.cxx:1248
 TFile.cxx:1249
 TFile.cxx:1250
 TFile.cxx:1251
 TFile.cxx:1252
 TFile.cxx:1253
 TFile.cxx:1254
 TFile.cxx:1255
 TFile.cxx:1256
 TFile.cxx:1257
 TFile.cxx:1258
 TFile.cxx:1259
 TFile.cxx:1260
 TFile.cxx:1261
 TFile.cxx:1262
 TFile.cxx:1263
 TFile.cxx:1264
 TFile.cxx:1265
 TFile.cxx:1266
 TFile.cxx:1267
 TFile.cxx:1268
 TFile.cxx:1269
 TFile.cxx:1270
 TFile.cxx:1271
 TFile.cxx:1272
 TFile.cxx:1273
 TFile.cxx:1274
 TFile.cxx:1275
 TFile.cxx:1276
 TFile.cxx:1277
 TFile.cxx:1278
 TFile.cxx:1279
 TFile.cxx:1280
 TFile.cxx:1281
 TFile.cxx:1282
 TFile.cxx:1283
 TFile.cxx:1284
 TFile.cxx:1285
 TFile.cxx:1286
 TFile.cxx:1287
 TFile.cxx:1288
 TFile.cxx:1289
 TFile.cxx:1290
 TFile.cxx:1291
 TFile.cxx:1292
 TFile.cxx:1293
 TFile.cxx:1294
 TFile.cxx:1295
 TFile.cxx:1296
 TFile.cxx:1297
 TFile.cxx:1298
 TFile.cxx:1299
 TFile.cxx:1300
 TFile.cxx:1301
 TFile.cxx:1302
 TFile.cxx:1303
 TFile.cxx:1304
 TFile.cxx:1305
 TFile.cxx:1306
 TFile.cxx:1307
 TFile.cxx:1308
 TFile.cxx:1309
 TFile.cxx:1310
 TFile.cxx:1311
 TFile.cxx:1312
 TFile.cxx:1313
 TFile.cxx:1314
 TFile.cxx:1315
 TFile.cxx:1316
 TFile.cxx:1317
 TFile.cxx:1318
 TFile.cxx:1319
 TFile.cxx:1320
 TFile.cxx:1321
 TFile.cxx:1322
 TFile.cxx:1323
 TFile.cxx:1324
 TFile.cxx:1325
 TFile.cxx:1326
 TFile.cxx:1327
 TFile.cxx:1328
 TFile.cxx:1329
 TFile.cxx:1330
 TFile.cxx:1331
 TFile.cxx:1332
 TFile.cxx:1333
 TFile.cxx:1334
 TFile.cxx:1335
 TFile.cxx:1336
 TFile.cxx:1337
 TFile.cxx:1338
 TFile.cxx:1339
 TFile.cxx:1340
 TFile.cxx:1341
 TFile.cxx:1342
 TFile.cxx:1343
 TFile.cxx:1344
 TFile.cxx:1345
 TFile.cxx:1346
 TFile.cxx:1347
 TFile.cxx:1348
 TFile.cxx:1349
 TFile.cxx:1350
 TFile.cxx:1351
 TFile.cxx:1352
 TFile.cxx:1353
 TFile.cxx:1354
 TFile.cxx:1355
 TFile.cxx:1356
 TFile.cxx:1357
 TFile.cxx:1358
 TFile.cxx:1359
 TFile.cxx:1360
 TFile.cxx:1361
 TFile.cxx:1362
 TFile.cxx:1363
 TFile.cxx:1364
 TFile.cxx:1365
 TFile.cxx:1366
 TFile.cxx:1367
 TFile.cxx:1368
 TFile.cxx:1369
 TFile.cxx:1370
 TFile.cxx:1371
 TFile.cxx:1372
 TFile.cxx:1373
 TFile.cxx:1374
 TFile.cxx:1375
 TFile.cxx:1376
 TFile.cxx:1377
 TFile.cxx:1378
 TFile.cxx:1379
 TFile.cxx:1380
 TFile.cxx:1381
 TFile.cxx:1382
 TFile.cxx:1383
 TFile.cxx:1384
 TFile.cxx:1385
 TFile.cxx:1386
 TFile.cxx:1387
 TFile.cxx:1388
 TFile.cxx:1389
 TFile.cxx:1390
 TFile.cxx:1391
 TFile.cxx:1392
 TFile.cxx:1393
 TFile.cxx:1394
 TFile.cxx:1395
 TFile.cxx:1396
 TFile.cxx:1397
 TFile.cxx:1398
 TFile.cxx:1399
 TFile.cxx:1400
 TFile.cxx:1401
 TFile.cxx:1402
 TFile.cxx:1403
 TFile.cxx:1404
 TFile.cxx:1405
 TFile.cxx:1406
 TFile.cxx:1407
 TFile.cxx:1408
 TFile.cxx:1409
 TFile.cxx:1410
 TFile.cxx:1411
 TFile.cxx:1412
 TFile.cxx:1413
 TFile.cxx:1414
 TFile.cxx:1415
 TFile.cxx:1416
 TFile.cxx:1417
 TFile.cxx:1418
 TFile.cxx:1419
 TFile.cxx:1420
 TFile.cxx:1421
 TFile.cxx:1422
 TFile.cxx:1423
 TFile.cxx:1424
 TFile.cxx:1425
 TFile.cxx:1426
 TFile.cxx:1427
 TFile.cxx:1428
 TFile.cxx:1429
 TFile.cxx:1430
 TFile.cxx:1431
 TFile.cxx:1432
 TFile.cxx:1433
 TFile.cxx:1434
 TFile.cxx:1435
 TFile.cxx:1436
 TFile.cxx:1437
 TFile.cxx:1438
 TFile.cxx:1439
 TFile.cxx:1440
 TFile.cxx:1441
 TFile.cxx:1442
 TFile.cxx:1443
 TFile.cxx:1444
 TFile.cxx:1445
 TFile.cxx:1446
 TFile.cxx:1447
 TFile.cxx:1448
 TFile.cxx:1449
 TFile.cxx:1450
 TFile.cxx:1451
 TFile.cxx:1452
 TFile.cxx:1453
 TFile.cxx:1454
 TFile.cxx:1455
 TFile.cxx:1456
 TFile.cxx:1457
 TFile.cxx:1458
 TFile.cxx:1459
 TFile.cxx:1460
 TFile.cxx:1461
 TFile.cxx:1462
 TFile.cxx:1463
 TFile.cxx:1464
 TFile.cxx:1465
 TFile.cxx:1466
 TFile.cxx:1467
 TFile.cxx:1468
 TFile.cxx:1469
 TFile.cxx:1470
 TFile.cxx:1471
 TFile.cxx:1472
 TFile.cxx:1473
 TFile.cxx:1474
 TFile.cxx:1475
 TFile.cxx:1476
 TFile.cxx:1477
 TFile.cxx:1478
 TFile.cxx:1479
 TFile.cxx:1480
 TFile.cxx:1481
 TFile.cxx:1482
 TFile.cxx:1483
 TFile.cxx:1484
 TFile.cxx:1485
 TFile.cxx:1486
 TFile.cxx:1487
 TFile.cxx:1488
 TFile.cxx:1489
 TFile.cxx:1490
 TFile.cxx:1491
 TFile.cxx:1492
 TFile.cxx:1493
 TFile.cxx:1494
 TFile.cxx:1495
 TFile.cxx:1496
 TFile.cxx:1497
 TFile.cxx:1498
 TFile.cxx:1499
 TFile.cxx:1500
 TFile.cxx:1501
 TFile.cxx:1502
 TFile.cxx:1503
 TFile.cxx:1504
 TFile.cxx:1505
 TFile.cxx:1506
 TFile.cxx:1507
 TFile.cxx:1508
 TFile.cxx:1509
 TFile.cxx:1510
 TFile.cxx:1511
 TFile.cxx:1512
 TFile.cxx:1513
 TFile.cxx:1514
 TFile.cxx:1515
 TFile.cxx:1516
 TFile.cxx:1517
 TFile.cxx:1518
 TFile.cxx:1519
 TFile.cxx:1520
 TFile.cxx:1521
 TFile.cxx:1522
 TFile.cxx:1523
 TFile.cxx:1524
 TFile.cxx:1525
 TFile.cxx:1526
 TFile.cxx:1527
 TFile.cxx:1528
 TFile.cxx:1529
 TFile.cxx:1530
 TFile.cxx:1531
 TFile.cxx:1532
 TFile.cxx:1533
 TFile.cxx:1534
 TFile.cxx:1535
 TFile.cxx:1536
 TFile.cxx:1537
 TFile.cxx:1538
 TFile.cxx:1539
 TFile.cxx:1540
 TFile.cxx:1541
 TFile.cxx:1542
 TFile.cxx:1543
 TFile.cxx:1544
 TFile.cxx:1545
 TFile.cxx:1546
 TFile.cxx:1547
 TFile.cxx:1548
 TFile.cxx:1549
 TFile.cxx:1550
 TFile.cxx:1551
 TFile.cxx:1552
 TFile.cxx:1553
 TFile.cxx:1554
 TFile.cxx:1555
 TFile.cxx:1556
 TFile.cxx:1557
 TFile.cxx:1558
 TFile.cxx:1559
 TFile.cxx:1560
 TFile.cxx:1561
 TFile.cxx:1562
 TFile.cxx:1563
 TFile.cxx:1564
 TFile.cxx:1565
 TFile.cxx:1566
 TFile.cxx:1567
 TFile.cxx:1568
 TFile.cxx:1569
 TFile.cxx:1570
 TFile.cxx:1571
 TFile.cxx:1572
 TFile.cxx:1573
 TFile.cxx:1574
 TFile.cxx:1575
 TFile.cxx:1576
 TFile.cxx:1577
 TFile.cxx:1578
 TFile.cxx:1579
 TFile.cxx:1580
 TFile.cxx:1581
 TFile.cxx:1582
 TFile.cxx:1583
 TFile.cxx:1584
 TFile.cxx:1585
 TFile.cxx:1586
 TFile.cxx:1587
 TFile.cxx:1588
 TFile.cxx:1589
 TFile.cxx:1590
 TFile.cxx:1591
 TFile.cxx:1592
 TFile.cxx:1593
 TFile.cxx:1594
 TFile.cxx:1595
 TFile.cxx:1596
 TFile.cxx:1597
 TFile.cxx:1598
 TFile.cxx:1599
 TFile.cxx:1600
 TFile.cxx:1601
 TFile.cxx:1602
 TFile.cxx:1603
 TFile.cxx:1604
 TFile.cxx:1605
 TFile.cxx:1606
 TFile.cxx:1607
 TFile.cxx:1608
 TFile.cxx:1609
 TFile.cxx:1610
 TFile.cxx:1611
 TFile.cxx:1612
 TFile.cxx:1613
 TFile.cxx:1614
 TFile.cxx:1615
 TFile.cxx:1616
 TFile.cxx:1617
 TFile.cxx:1618
 TFile.cxx:1619
 TFile.cxx:1620
 TFile.cxx:1621
 TFile.cxx:1622
 TFile.cxx:1623
 TFile.cxx:1624
 TFile.cxx:1625
 TFile.cxx:1626
 TFile.cxx:1627
 TFile.cxx:1628
 TFile.cxx:1629
 TFile.cxx:1630
 TFile.cxx:1631
 TFile.cxx:1632
 TFile.cxx:1633
 TFile.cxx:1634
 TFile.cxx:1635
 TFile.cxx:1636
 TFile.cxx:1637
 TFile.cxx:1638
 TFile.cxx:1639
 TFile.cxx:1640
 TFile.cxx:1641
 TFile.cxx:1642
 TFile.cxx:1643
 TFile.cxx:1644
 TFile.cxx:1645
 TFile.cxx:1646
 TFile.cxx:1647
 TFile.cxx:1648
 TFile.cxx:1649
 TFile.cxx:1650
 TFile.cxx:1651
 TFile.cxx:1652
 TFile.cxx:1653
 TFile.cxx:1654
 TFile.cxx:1655
 TFile.cxx:1656
 TFile.cxx:1657
 TFile.cxx:1658
 TFile.cxx:1659
 TFile.cxx:1660
 TFile.cxx:1661
 TFile.cxx:1662
 TFile.cxx:1663
 TFile.cxx:1664
 TFile.cxx:1665
 TFile.cxx:1666
 TFile.cxx:1667
 TFile.cxx:1668
 TFile.cxx:1669
 TFile.cxx:1670
 TFile.cxx:1671
 TFile.cxx:1672
 TFile.cxx:1673
 TFile.cxx:1674
 TFile.cxx:1675
 TFile.cxx:1676
 TFile.cxx:1677
 TFile.cxx:1678
 TFile.cxx:1679
 TFile.cxx:1680
 TFile.cxx:1681
 TFile.cxx:1682
 TFile.cxx:1683
 TFile.cxx:1684
 TFile.cxx:1685
 TFile.cxx:1686
 TFile.cxx:1687
 TFile.cxx:1688
 TFile.cxx:1689
 TFile.cxx:1690
 TFile.cxx:1691
 TFile.cxx:1692
 TFile.cxx:1693
 TFile.cxx:1694
 TFile.cxx:1695
 TFile.cxx:1696
 TFile.cxx:1697
 TFile.cxx:1698
 TFile.cxx:1699
 TFile.cxx:1700
 TFile.cxx:1701
 TFile.cxx:1702
 TFile.cxx:1703
 TFile.cxx:1704
 TFile.cxx:1705
 TFile.cxx:1706
 TFile.cxx:1707
 TFile.cxx:1708
 TFile.cxx:1709
 TFile.cxx:1710
 TFile.cxx:1711
 TFile.cxx:1712
 TFile.cxx:1713
 TFile.cxx:1714
 TFile.cxx:1715
 TFile.cxx:1716
 TFile.cxx:1717
 TFile.cxx:1718
 TFile.cxx:1719
 TFile.cxx:1720
 TFile.cxx:1721
 TFile.cxx:1722
 TFile.cxx:1723
 TFile.cxx:1724
 TFile.cxx:1725
 TFile.cxx:1726
 TFile.cxx:1727
 TFile.cxx:1728
 TFile.cxx:1729
 TFile.cxx:1730
 TFile.cxx:1731
 TFile.cxx:1732
 TFile.cxx:1733
 TFile.cxx:1734
 TFile.cxx:1735
 TFile.cxx:1736
 TFile.cxx:1737
 TFile.cxx:1738
 TFile.cxx:1739
 TFile.cxx:1740
 TFile.cxx:1741
 TFile.cxx:1742
 TFile.cxx:1743
 TFile.cxx:1744
 TFile.cxx:1745
 TFile.cxx:1746
 TFile.cxx:1747
 TFile.cxx:1748
 TFile.cxx:1749
 TFile.cxx:1750
 TFile.cxx:1751
 TFile.cxx:1752
 TFile.cxx:1753
 TFile.cxx:1754
 TFile.cxx:1755
 TFile.cxx:1756
 TFile.cxx:1757
 TFile.cxx:1758
 TFile.cxx:1759
 TFile.cxx:1760
 TFile.cxx:1761
 TFile.cxx:1762
 TFile.cxx:1763
 TFile.cxx:1764
 TFile.cxx:1765
 TFile.cxx:1766
 TFile.cxx:1767
 TFile.cxx:1768
 TFile.cxx:1769
 TFile.cxx:1770
 TFile.cxx:1771
 TFile.cxx:1772
 TFile.cxx:1773
 TFile.cxx:1774
 TFile.cxx:1775
 TFile.cxx:1776
 TFile.cxx:1777
 TFile.cxx:1778
 TFile.cxx:1779
 TFile.cxx:1780
 TFile.cxx:1781
 TFile.cxx:1782
 TFile.cxx:1783
 TFile.cxx:1784
 TFile.cxx:1785
 TFile.cxx:1786
 TFile.cxx:1787
 TFile.cxx:1788
 TFile.cxx:1789
 TFile.cxx:1790
 TFile.cxx:1791
 TFile.cxx:1792
 TFile.cxx:1793
 TFile.cxx:1794
 TFile.cxx:1795
 TFile.cxx:1796
 TFile.cxx:1797
 TFile.cxx:1798
 TFile.cxx:1799
 TFile.cxx:1800
 TFile.cxx:1801
 TFile.cxx:1802
 TFile.cxx:1803
 TFile.cxx:1804
 TFile.cxx:1805
 TFile.cxx:1806
 TFile.cxx:1807
 TFile.cxx:1808
 TFile.cxx:1809
 TFile.cxx:1810
 TFile.cxx:1811
 TFile.cxx:1812
 TFile.cxx:1813
 TFile.cxx:1814
 TFile.cxx:1815
 TFile.cxx:1816
 TFile.cxx:1817
 TFile.cxx:1818
 TFile.cxx:1819
 TFile.cxx:1820
 TFile.cxx:1821
 TFile.cxx:1822
 TFile.cxx:1823
 TFile.cxx:1824
 TFile.cxx:1825
 TFile.cxx:1826
 TFile.cxx:1827
 TFile.cxx:1828
 TFile.cxx:1829
 TFile.cxx:1830
 TFile.cxx:1831
 TFile.cxx:1832
 TFile.cxx:1833
 TFile.cxx:1834
 TFile.cxx:1835
 TFile.cxx:1836
 TFile.cxx:1837
 TFile.cxx:1838
 TFile.cxx:1839
 TFile.cxx:1840
 TFile.cxx:1841
 TFile.cxx:1842
 TFile.cxx:1843
 TFile.cxx:1844
 TFile.cxx:1845
 TFile.cxx:1846
 TFile.cxx:1847
 TFile.cxx:1848
 TFile.cxx:1849
 TFile.cxx:1850
 TFile.cxx:1851
 TFile.cxx:1852
 TFile.cxx:1853
 TFile.cxx:1854
 TFile.cxx:1855
 TFile.cxx:1856
 TFile.cxx:1857
 TFile.cxx:1858
 TFile.cxx:1859
 TFile.cxx:1860
 TFile.cxx:1861
 TFile.cxx:1862
 TFile.cxx:1863
 TFile.cxx:1864
 TFile.cxx:1865
 TFile.cxx:1866
 TFile.cxx:1867
 TFile.cxx:1868
 TFile.cxx:1869
 TFile.cxx:1870
 TFile.cxx:1871
 TFile.cxx:1872
 TFile.cxx:1873
 TFile.cxx:1874
 TFile.cxx:1875
 TFile.cxx:1876
 TFile.cxx:1877
 TFile.cxx:1878
 TFile.cxx:1879
 TFile.cxx:1880
 TFile.cxx:1881
 TFile.cxx:1882
 TFile.cxx:1883
 TFile.cxx:1884
 TFile.cxx:1885
 TFile.cxx:1886
 TFile.cxx:1887
 TFile.cxx:1888
 TFile.cxx:1889
 TFile.cxx:1890
 TFile.cxx:1891
 TFile.cxx:1892
 TFile.cxx:1893
 TFile.cxx:1894
 TFile.cxx:1895
 TFile.cxx:1896
 TFile.cxx:1897
 TFile.cxx:1898
 TFile.cxx:1899
 TFile.cxx:1900
 TFile.cxx:1901
 TFile.cxx:1902
 TFile.cxx:1903
 TFile.cxx:1904
 TFile.cxx:1905
 TFile.cxx:1906
 TFile.cxx:1907
 TFile.cxx:1908
 TFile.cxx:1909
 TFile.cxx:1910
 TFile.cxx:1911
 TFile.cxx:1912
 TFile.cxx:1913
 TFile.cxx:1914
 TFile.cxx:1915
 TFile.cxx:1916
 TFile.cxx:1917
 TFile.cxx:1918
 TFile.cxx:1919
 TFile.cxx:1920
 TFile.cxx:1921
 TFile.cxx:1922
 TFile.cxx:1923
 TFile.cxx:1924
 TFile.cxx:1925
 TFile.cxx:1926
 TFile.cxx:1927
 TFile.cxx:1928
 TFile.cxx:1929
 TFile.cxx:1930
 TFile.cxx:1931
 TFile.cxx:1932
 TFile.cxx:1933
 TFile.cxx:1934
 TFile.cxx:1935
 TFile.cxx:1936
 TFile.cxx:1937
 TFile.cxx:1938
 TFile.cxx:1939
 TFile.cxx:1940
 TFile.cxx:1941
 TFile.cxx:1942
 TFile.cxx:1943
 TFile.cxx:1944
 TFile.cxx:1945
 TFile.cxx:1946
 TFile.cxx:1947
 TFile.cxx:1948
 TFile.cxx:1949
 TFile.cxx:1950
 TFile.cxx:1951
 TFile.cxx:1952
 TFile.cxx:1953
 TFile.cxx:1954
 TFile.cxx:1955
 TFile.cxx:1956
 TFile.cxx:1957
 TFile.cxx:1958
 TFile.cxx:1959
 TFile.cxx:1960
 TFile.cxx:1961
 TFile.cxx:1962
 TFile.cxx:1963
 TFile.cxx:1964
 TFile.cxx:1965
 TFile.cxx:1966
 TFile.cxx:1967
 TFile.cxx:1968
 TFile.cxx:1969
 TFile.cxx:1970
 TFile.cxx:1971
 TFile.cxx:1972
 TFile.cxx:1973
 TFile.cxx:1974
 TFile.cxx:1975
 TFile.cxx:1976
 TFile.cxx:1977
 TFile.cxx:1978
 TFile.cxx:1979
 TFile.cxx:1980
 TFile.cxx:1981
 TFile.cxx:1982
 TFile.cxx:1983
 TFile.cxx:1984
 TFile.cxx:1985
 TFile.cxx:1986
 TFile.cxx:1987
 TFile.cxx:1988
 TFile.cxx:1989
 TFile.cxx:1990
 TFile.cxx:1991
 TFile.cxx:1992
 TFile.cxx:1993
 TFile.cxx:1994
 TFile.cxx:1995
 TFile.cxx:1996
 TFile.cxx:1997
 TFile.cxx:1998
 TFile.cxx:1999
 TFile.cxx:2000
 TFile.cxx:2001
 TFile.cxx:2002
 TFile.cxx:2003
 TFile.cxx:2004
 TFile.cxx:2005
 TFile.cxx:2006
 TFile.cxx:2007
 TFile.cxx:2008
 TFile.cxx:2009
 TFile.cxx:2010
 TFile.cxx:2011
 TFile.cxx:2012
 TFile.cxx:2013
 TFile.cxx:2014
 TFile.cxx:2015
 TFile.cxx:2016
 TFile.cxx:2017
 TFile.cxx:2018
 TFile.cxx:2019
 TFile.cxx:2020
 TFile.cxx:2021
 TFile.cxx:2022
 TFile.cxx:2023
 TFile.cxx:2024
 TFile.cxx:2025
 TFile.cxx:2026
 TFile.cxx:2027
 TFile.cxx:2028
 TFile.cxx:2029
 TFile.cxx:2030
 TFile.cxx:2031
 TFile.cxx:2032
 TFile.cxx:2033
 TFile.cxx:2034
 TFile.cxx:2035
 TFile.cxx:2036
 TFile.cxx:2037
 TFile.cxx:2038
 TFile.cxx:2039
 TFile.cxx:2040
 TFile.cxx:2041
 TFile.cxx:2042
 TFile.cxx:2043
 TFile.cxx:2044
 TFile.cxx:2045
 TFile.cxx:2046
 TFile.cxx:2047
 TFile.cxx:2048
 TFile.cxx:2049
 TFile.cxx:2050
 TFile.cxx:2051
 TFile.cxx:2052
 TFile.cxx:2053
 TFile.cxx:2054
 TFile.cxx:2055
 TFile.cxx:2056
 TFile.cxx:2057
 TFile.cxx:2058
 TFile.cxx:2059
 TFile.cxx:2060
 TFile.cxx:2061
 TFile.cxx:2062
 TFile.cxx:2063
 TFile.cxx:2064
 TFile.cxx:2065
 TFile.cxx:2066
 TFile.cxx:2067
 TFile.cxx:2068
 TFile.cxx:2069
 TFile.cxx:2070
 TFile.cxx:2071
 TFile.cxx:2072
 TFile.cxx:2073
 TFile.cxx:2074
 TFile.cxx:2075
 TFile.cxx:2076
 TFile.cxx:2077
 TFile.cxx:2078
 TFile.cxx:2079
 TFile.cxx:2080
 TFile.cxx:2081
 TFile.cxx:2082
 TFile.cxx:2083
 TFile.cxx:2084
 TFile.cxx:2085
 TFile.cxx:2086
 TFile.cxx:2087
 TFile.cxx:2088
 TFile.cxx:2089
 TFile.cxx:2090
 TFile.cxx:2091
 TFile.cxx:2092
 TFile.cxx:2093
 TFile.cxx:2094
 TFile.cxx:2095
 TFile.cxx:2096
 TFile.cxx:2097
 TFile.cxx:2098
 TFile.cxx:2099
 TFile.cxx:2100
 TFile.cxx:2101
 TFile.cxx:2102
 TFile.cxx:2103
 TFile.cxx:2104
 TFile.cxx:2105
 TFile.cxx:2106
 TFile.cxx:2107
 TFile.cxx:2108
 TFile.cxx:2109
 TFile.cxx:2110
 TFile.cxx:2111
 TFile.cxx:2112
 TFile.cxx:2113
 TFile.cxx:2114
 TFile.cxx:2115
 TFile.cxx:2116
 TFile.cxx:2117
 TFile.cxx:2118
 TFile.cxx:2119
 TFile.cxx:2120
 TFile.cxx:2121
 TFile.cxx:2122
 TFile.cxx:2123
 TFile.cxx:2124
 TFile.cxx:2125
 TFile.cxx:2126
 TFile.cxx:2127
 TFile.cxx:2128
 TFile.cxx:2129
 TFile.cxx:2130
 TFile.cxx:2131
 TFile.cxx:2132
 TFile.cxx:2133
 TFile.cxx:2134
 TFile.cxx:2135
 TFile.cxx:2136
 TFile.cxx:2137
 TFile.cxx:2138
 TFile.cxx:2139
 TFile.cxx:2140
 TFile.cxx:2141
 TFile.cxx:2142
 TFile.cxx:2143
 TFile.cxx:2144
 TFile.cxx:2145
 TFile.cxx:2146
 TFile.cxx:2147
 TFile.cxx:2148
 TFile.cxx:2149
 TFile.cxx:2150
 TFile.cxx:2151
 TFile.cxx:2152
 TFile.cxx:2153
 TFile.cxx:2154
 TFile.cxx:2155
 TFile.cxx:2156
 TFile.cxx:2157
 TFile.cxx:2158
 TFile.cxx:2159
 TFile.cxx:2160
 TFile.cxx:2161
 TFile.cxx:2162
 TFile.cxx:2163
 TFile.cxx:2164
 TFile.cxx:2165
 TFile.cxx:2166
 TFile.cxx:2167
 TFile.cxx:2168
 TFile.cxx:2169
 TFile.cxx:2170
 TFile.cxx:2171
 TFile.cxx:2172
 TFile.cxx:2173
 TFile.cxx:2174
 TFile.cxx:2175
 TFile.cxx:2176
 TFile.cxx:2177
 TFile.cxx:2178
 TFile.cxx:2179
 TFile.cxx:2180
 TFile.cxx:2181
 TFile.cxx:2182
 TFile.cxx:2183
 TFile.cxx:2184
 TFile.cxx:2185
 TFile.cxx:2186
 TFile.cxx:2187
 TFile.cxx:2188
 TFile.cxx:2189
 TFile.cxx:2190
 TFile.cxx:2191
 TFile.cxx:2192
 TFile.cxx:2193
 TFile.cxx:2194
 TFile.cxx:2195
 TFile.cxx:2196
 TFile.cxx:2197
 TFile.cxx:2198
 TFile.cxx:2199
 TFile.cxx:2200
 TFile.cxx:2201
 TFile.cxx:2202
 TFile.cxx:2203
 TFile.cxx:2204
 TFile.cxx:2205
 TFile.cxx:2206
 TFile.cxx:2207
 TFile.cxx:2208
 TFile.cxx:2209
 TFile.cxx:2210
 TFile.cxx:2211
 TFile.cxx:2212
 TFile.cxx:2213
 TFile.cxx:2214
 TFile.cxx:2215
 TFile.cxx:2216
 TFile.cxx:2217
 TFile.cxx:2218
 TFile.cxx:2219
 TFile.cxx:2220
 TFile.cxx:2221
 TFile.cxx:2222
 TFile.cxx:2223
 TFile.cxx:2224
 TFile.cxx:2225
 TFile.cxx:2226
 TFile.cxx:2227
 TFile.cxx:2228
 TFile.cxx:2229
 TFile.cxx:2230
 TFile.cxx:2231
 TFile.cxx:2232
 TFile.cxx:2233
 TFile.cxx:2234
 TFile.cxx:2235
 TFile.cxx:2236
 TFile.cxx:2237
 TFile.cxx:2238
 TFile.cxx:2239
 TFile.cxx:2240
 TFile.cxx:2241
 TFile.cxx:2242
 TFile.cxx:2243
 TFile.cxx:2244
 TFile.cxx:2245
 TFile.cxx:2246
 TFile.cxx:2247
 TFile.cxx:2248
 TFile.cxx:2249
 TFile.cxx:2250
 TFile.cxx:2251
 TFile.cxx:2252
 TFile.cxx:2253
 TFile.cxx:2254
 TFile.cxx:2255
 TFile.cxx:2256
 TFile.cxx:2257
 TFile.cxx:2258
 TFile.cxx:2259
 TFile.cxx:2260
 TFile.cxx:2261
 TFile.cxx:2262
 TFile.cxx:2263
 TFile.cxx:2264
 TFile.cxx:2265
 TFile.cxx:2266
 TFile.cxx:2267
 TFile.cxx:2268
 TFile.cxx:2269
 TFile.cxx:2270
 TFile.cxx:2271
 TFile.cxx:2272
 TFile.cxx:2273
 TFile.cxx:2274
 TFile.cxx:2275
 TFile.cxx:2276
 TFile.cxx:2277
 TFile.cxx:2278
 TFile.cxx:2279
 TFile.cxx:2280
 TFile.cxx:2281
 TFile.cxx:2282
 TFile.cxx:2283
 TFile.cxx:2284
 TFile.cxx:2285
 TFile.cxx:2286
 TFile.cxx:2287
 TFile.cxx:2288
 TFile.cxx:2289
 TFile.cxx:2290
 TFile.cxx:2291
 TFile.cxx:2292
 TFile.cxx:2293
 TFile.cxx:2294
 TFile.cxx:2295
 TFile.cxx:2296
 TFile.cxx:2297
 TFile.cxx:2298
 TFile.cxx:2299
 TFile.cxx:2300
 TFile.cxx:2301
 TFile.cxx:2302
 TFile.cxx:2303
 TFile.cxx:2304
 TFile.cxx:2305
 TFile.cxx:2306
 TFile.cxx:2307
 TFile.cxx:2308
 TFile.cxx:2309
 TFile.cxx:2310
 TFile.cxx:2311
 TFile.cxx:2312
 TFile.cxx:2313
 TFile.cxx:2314
 TFile.cxx:2315
 TFile.cxx:2316
 TFile.cxx:2317
 TFile.cxx:2318
 TFile.cxx:2319
 TFile.cxx:2320
 TFile.cxx:2321
 TFile.cxx:2322
 TFile.cxx:2323
 TFile.cxx:2324
 TFile.cxx:2325
 TFile.cxx:2326
 TFile.cxx:2327
 TFile.cxx:2328
 TFile.cxx:2329
 TFile.cxx:2330
 TFile.cxx:2331
 TFile.cxx:2332
 TFile.cxx:2333
 TFile.cxx:2334
 TFile.cxx:2335
 TFile.cxx:2336
 TFile.cxx:2337
 TFile.cxx:2338
 TFile.cxx:2339
 TFile.cxx:2340
 TFile.cxx:2341
 TFile.cxx:2342
 TFile.cxx:2343
 TFile.cxx:2344
 TFile.cxx:2345
 TFile.cxx:2346
 TFile.cxx:2347
 TFile.cxx:2348
 TFile.cxx:2349
 TFile.cxx:2350
 TFile.cxx:2351
 TFile.cxx:2352
 TFile.cxx:2353
 TFile.cxx:2354
 TFile.cxx:2355
 TFile.cxx:2356
 TFile.cxx:2357
 TFile.cxx:2358
 TFile.cxx:2359
 TFile.cxx:2360
 TFile.cxx:2361
 TFile.cxx:2362
 TFile.cxx:2363
 TFile.cxx:2364
 TFile.cxx:2365
 TFile.cxx:2366
 TFile.cxx:2367
 TFile.cxx:2368
 TFile.cxx:2369
 TFile.cxx:2370
 TFile.cxx:2371
 TFile.cxx:2372
 TFile.cxx:2373
 TFile.cxx:2374
 TFile.cxx:2375
 TFile.cxx:2376
 TFile.cxx:2377
 TFile.cxx:2378
 TFile.cxx:2379
 TFile.cxx:2380
 TFile.cxx:2381
 TFile.cxx:2382
 TFile.cxx:2383
 TFile.cxx:2384
 TFile.cxx:2385
 TFile.cxx:2386
 TFile.cxx:2387
 TFile.cxx:2388
 TFile.cxx:2389
 TFile.cxx:2390
 TFile.cxx:2391
 TFile.cxx:2392
 TFile.cxx:2393
 TFile.cxx:2394
 TFile.cxx:2395
 TFile.cxx:2396
 TFile.cxx:2397
 TFile.cxx:2398
 TFile.cxx:2399
 TFile.cxx:2400
 TFile.cxx:2401
 TFile.cxx:2402
 TFile.cxx:2403
 TFile.cxx:2404
 TFile.cxx:2405
 TFile.cxx:2406
 TFile.cxx:2407
 TFile.cxx:2408
 TFile.cxx:2409
 TFile.cxx:2410
 TFile.cxx:2411
 TFile.cxx:2412
 TFile.cxx:2413
 TFile.cxx:2414
 TFile.cxx:2415
 TFile.cxx:2416
 TFile.cxx:2417
 TFile.cxx:2418
 TFile.cxx:2419
 TFile.cxx:2420
 TFile.cxx:2421
 TFile.cxx:2422
 TFile.cxx:2423
 TFile.cxx:2424
 TFile.cxx:2425
 TFile.cxx:2426
 TFile.cxx:2427
 TFile.cxx:2428
 TFile.cxx:2429
 TFile.cxx:2430
 TFile.cxx:2431
 TFile.cxx:2432
 TFile.cxx:2433
 TFile.cxx:2434
 TFile.cxx:2435
 TFile.cxx:2436
 TFile.cxx:2437
 TFile.cxx:2438
 TFile.cxx:2439
 TFile.cxx:2440
 TFile.cxx:2441
 TFile.cxx:2442
 TFile.cxx:2443
 TFile.cxx:2444
 TFile.cxx:2445
 TFile.cxx:2446
 TFile.cxx:2447
 TFile.cxx:2448
 TFile.cxx:2449
 TFile.cxx:2450
 TFile.cxx:2451
 TFile.cxx:2452
 TFile.cxx:2453
 TFile.cxx:2454
 TFile.cxx:2455
 TFile.cxx:2456
 TFile.cxx:2457
 TFile.cxx:2458
 TFile.cxx:2459
 TFile.cxx:2460
 TFile.cxx:2461
 TFile.cxx:2462
 TFile.cxx:2463
 TFile.cxx:2464
 TFile.cxx:2465
 TFile.cxx:2466
 TFile.cxx:2467
 TFile.cxx:2468
 TFile.cxx:2469
 TFile.cxx:2470
 TFile.cxx:2471
 TFile.cxx:2472
 TFile.cxx:2473
 TFile.cxx:2474
 TFile.cxx:2475
 TFile.cxx:2476
 TFile.cxx:2477
 TFile.cxx:2478
 TFile.cxx:2479
 TFile.cxx:2480
 TFile.cxx:2481
 TFile.cxx:2482
 TFile.cxx:2483
 TFile.cxx:2484
 TFile.cxx:2485
 TFile.cxx:2486
 TFile.cxx:2487
 TFile.cxx:2488
 TFile.cxx:2489
 TFile.cxx:2490
 TFile.cxx:2491
 TFile.cxx:2492
 TFile.cxx:2493
 TFile.cxx:2494
 TFile.cxx:2495
 TFile.cxx:2496
 TFile.cxx:2497
 TFile.cxx:2498
 TFile.cxx:2499
 TFile.cxx:2500
 TFile.cxx:2501
 TFile.cxx:2502
 TFile.cxx:2503
 TFile.cxx:2504
 TFile.cxx:2505
 TFile.cxx:2506
 TFile.cxx:2507
 TFile.cxx:2508
 TFile.cxx:2509
 TFile.cxx:2510
 TFile.cxx:2511
 TFile.cxx:2512
 TFile.cxx:2513
 TFile.cxx:2514
 TFile.cxx:2515
 TFile.cxx:2516
 TFile.cxx:2517
 TFile.cxx:2518
 TFile.cxx:2519
 TFile.cxx:2520
 TFile.cxx:2521
 TFile.cxx:2522
 TFile.cxx:2523
 TFile.cxx:2524
 TFile.cxx:2525
 TFile.cxx:2526
 TFile.cxx:2527
 TFile.cxx:2528
 TFile.cxx:2529
 TFile.cxx:2530
 TFile.cxx:2531
 TFile.cxx:2532
 TFile.cxx:2533
 TFile.cxx:2534
 TFile.cxx:2535
 TFile.cxx:2536
 TFile.cxx:2537
 TFile.cxx:2538
 TFile.cxx:2539
 TFile.cxx:2540
 TFile.cxx:2541
 TFile.cxx:2542
 TFile.cxx:2543
 TFile.cxx:2544
 TFile.cxx:2545
 TFile.cxx:2546
 TFile.cxx:2547
 TFile.cxx:2548
 TFile.cxx:2549
 TFile.cxx:2550
 TFile.cxx:2551
 TFile.cxx:2552
 TFile.cxx:2553
 TFile.cxx:2554
 TFile.cxx:2555
 TFile.cxx:2556
 TFile.cxx:2557
 TFile.cxx:2558
 TFile.cxx:2559
 TFile.cxx:2560
 TFile.cxx:2561
 TFile.cxx:2562
 TFile.cxx:2563
 TFile.cxx:2564
 TFile.cxx:2565
 TFile.cxx:2566
 TFile.cxx:2567
 TFile.cxx:2568
 TFile.cxx:2569
 TFile.cxx:2570
 TFile.cxx:2571
 TFile.cxx:2572
 TFile.cxx:2573
 TFile.cxx:2574
 TFile.cxx:2575
 TFile.cxx:2576
 TFile.cxx:2577
 TFile.cxx:2578
 TFile.cxx:2579
 TFile.cxx:2580
 TFile.cxx:2581
 TFile.cxx:2582
 TFile.cxx:2583
 TFile.cxx:2584
 TFile.cxx:2585
 TFile.cxx:2586
 TFile.cxx:2587
 TFile.cxx:2588
 TFile.cxx:2589
 TFile.cxx:2590
 TFile.cxx:2591
 TFile.cxx:2592
 TFile.cxx:2593
 TFile.cxx:2594
 TFile.cxx:2595
 TFile.cxx:2596
 TFile.cxx:2597
 TFile.cxx:2598
 TFile.cxx:2599
 TFile.cxx:2600
 TFile.cxx:2601
 TFile.cxx:2602
 TFile.cxx:2603
 TFile.cxx:2604
 TFile.cxx:2605
 TFile.cxx:2606
 TFile.cxx:2607
 TFile.cxx:2608
 TFile.cxx:2609
 TFile.cxx:2610
 TFile.cxx:2611
 TFile.cxx:2612
 TFile.cxx:2613
 TFile.cxx:2614
 TFile.cxx:2615
 TFile.cxx:2616
 TFile.cxx:2617
 TFile.cxx:2618
 TFile.cxx:2619
 TFile.cxx:2620
 TFile.cxx:2621
 TFile.cxx:2622
 TFile.cxx:2623
 TFile.cxx:2624
 TFile.cxx:2625
 TFile.cxx:2626
 TFile.cxx:2627
 TFile.cxx:2628
 TFile.cxx:2629
 TFile.cxx:2630
 TFile.cxx:2631
 TFile.cxx:2632
 TFile.cxx:2633
 TFile.cxx:2634
 TFile.cxx:2635
 TFile.cxx:2636
 TFile.cxx:2637
 TFile.cxx:2638
 TFile.cxx:2639
 TFile.cxx:2640
 TFile.cxx:2641
 TFile.cxx:2642
 TFile.cxx:2643
 TFile.cxx:2644
 TFile.cxx:2645
 TFile.cxx:2646
 TFile.cxx:2647
 TFile.cxx:2648
 TFile.cxx:2649
 TFile.cxx:2650
 TFile.cxx:2651
 TFile.cxx:2652
 TFile.cxx:2653
 TFile.cxx:2654
 TFile.cxx:2655
 TFile.cxx:2656
 TFile.cxx:2657
 TFile.cxx:2658
 TFile.cxx:2659
 TFile.cxx:2660
 TFile.cxx:2661
 TFile.cxx:2662
 TFile.cxx:2663
 TFile.cxx:2664
 TFile.cxx:2665
 TFile.cxx:2666
 TFile.cxx:2667
 TFile.cxx:2668
 TFile.cxx:2669
 TFile.cxx:2670
 TFile.cxx:2671
 TFile.cxx:2672
 TFile.cxx:2673
 TFile.cxx:2674
 TFile.cxx:2675
 TFile.cxx:2676
 TFile.cxx:2677
 TFile.cxx:2678
 TFile.cxx:2679
 TFile.cxx:2680
 TFile.cxx:2681
 TFile.cxx:2682
 TFile.cxx:2683
 TFile.cxx:2684
 TFile.cxx:2685
 TFile.cxx:2686
 TFile.cxx:2687
 TFile.cxx:2688
 TFile.cxx:2689
 TFile.cxx:2690
 TFile.cxx:2691
 TFile.cxx:2692
 TFile.cxx:2693
 TFile.cxx:2694
 TFile.cxx:2695
 TFile.cxx:2696
 TFile.cxx:2697
 TFile.cxx:2698
 TFile.cxx:2699
 TFile.cxx:2700
 TFile.cxx:2701
 TFile.cxx:2702
 TFile.cxx:2703
 TFile.cxx:2704
 TFile.cxx:2705
 TFile.cxx:2706
 TFile.cxx:2707
 TFile.cxx:2708
 TFile.cxx:2709
 TFile.cxx:2710
 TFile.cxx:2711
 TFile.cxx:2712
 TFile.cxx:2713
 TFile.cxx:2714
 TFile.cxx:2715
 TFile.cxx:2716
 TFile.cxx:2717
 TFile.cxx:2718
 TFile.cxx:2719
 TFile.cxx:2720
 TFile.cxx:2721
 TFile.cxx:2722
 TFile.cxx:2723
 TFile.cxx:2724
 TFile.cxx:2725
 TFile.cxx:2726
 TFile.cxx:2727
 TFile.cxx:2728
 TFile.cxx:2729
 TFile.cxx:2730
 TFile.cxx:2731
 TFile.cxx:2732
 TFile.cxx:2733
 TFile.cxx:2734
 TFile.cxx:2735
 TFile.cxx:2736
 TFile.cxx:2737
 TFile.cxx:2738
 TFile.cxx:2739
 TFile.cxx:2740
 TFile.cxx:2741
 TFile.cxx:2742
 TFile.cxx:2743
 TFile.cxx:2744
 TFile.cxx:2745
 TFile.cxx:2746
 TFile.cxx:2747
 TFile.cxx:2748
 TFile.cxx:2749
 TFile.cxx:2750
 TFile.cxx:2751
 TFile.cxx:2752
 TFile.cxx:2753
 TFile.cxx:2754
 TFile.cxx:2755
 TFile.cxx:2756
 TFile.cxx:2757
 TFile.cxx:2758
 TFile.cxx:2759
 TFile.cxx:2760
 TFile.cxx:2761
 TFile.cxx:2762
 TFile.cxx:2763
 TFile.cxx:2764
 TFile.cxx:2765
 TFile.cxx:2766
 TFile.cxx:2767
 TFile.cxx:2768
 TFile.cxx:2769
 TFile.cxx:2770
 TFile.cxx:2771
 TFile.cxx:2772
 TFile.cxx:2773
 TFile.cxx:2774
 TFile.cxx:2775
 TFile.cxx:2776
 TFile.cxx:2777
 TFile.cxx:2778
 TFile.cxx:2779
 TFile.cxx:2780
 TFile.cxx:2781
 TFile.cxx:2782
 TFile.cxx:2783
 TFile.cxx:2784
 TFile.cxx:2785
 TFile.cxx:2786
 TFile.cxx:2787
 TFile.cxx:2788
 TFile.cxx:2789
 TFile.cxx:2790
 TFile.cxx:2791
 TFile.cxx:2792
 TFile.cxx:2793
 TFile.cxx:2794
 TFile.cxx:2795
 TFile.cxx:2796
 TFile.cxx:2797
 TFile.cxx:2798
 TFile.cxx:2799
 TFile.cxx:2800
 TFile.cxx:2801
 TFile.cxx:2802
 TFile.cxx:2803
 TFile.cxx:2804
 TFile.cxx:2805
 TFile.cxx:2806
 TFile.cxx:2807
 TFile.cxx:2808
 TFile.cxx:2809
 TFile.cxx:2810
 TFile.cxx:2811
 TFile.cxx:2812
 TFile.cxx:2813
 TFile.cxx:2814
 TFile.cxx:2815
 TFile.cxx:2816
 TFile.cxx:2817
 TFile.cxx:2818
 TFile.cxx:2819
 TFile.cxx:2820
 TFile.cxx:2821
 TFile.cxx:2822
 TFile.cxx:2823
 TFile.cxx:2824
 TFile.cxx:2825
 TFile.cxx:2826
 TFile.cxx:2827
 TFile.cxx:2828
 TFile.cxx:2829
 TFile.cxx:2830
 TFile.cxx:2831
 TFile.cxx:2832
 TFile.cxx:2833
 TFile.cxx:2834
 TFile.cxx:2835
 TFile.cxx:2836
 TFile.cxx:2837
 TFile.cxx:2838
 TFile.cxx:2839
 TFile.cxx:2840
 TFile.cxx:2841
 TFile.cxx:2842
 TFile.cxx:2843
 TFile.cxx:2844
 TFile.cxx:2845
 TFile.cxx:2846
 TFile.cxx:2847
 TFile.cxx:2848
 TFile.cxx:2849
 TFile.cxx:2850
 TFile.cxx:2851
 TFile.cxx:2852
 TFile.cxx:2853
 TFile.cxx:2854
 TFile.cxx:2855
 TFile.cxx:2856
 TFile.cxx:2857
 TFile.cxx:2858
 TFile.cxx:2859
 TFile.cxx:2860
 TFile.cxx:2861
 TFile.cxx:2862
 TFile.cxx:2863
 TFile.cxx:2864
 TFile.cxx:2865
 TFile.cxx:2866
 TFile.cxx:2867
 TFile.cxx:2868
 TFile.cxx:2869
 TFile.cxx:2870
 TFile.cxx:2871
 TFile.cxx:2872
 TFile.cxx:2873
 TFile.cxx:2874
 TFile.cxx:2875
 TFile.cxx:2876
 TFile.cxx:2877
 TFile.cxx:2878
 TFile.cxx:2879
 TFile.cxx:2880
 TFile.cxx:2881
 TFile.cxx:2882
 TFile.cxx:2883
 TFile.cxx:2884
 TFile.cxx:2885
 TFile.cxx:2886
 TFile.cxx:2887
 TFile.cxx:2888
 TFile.cxx:2889
 TFile.cxx:2890
 TFile.cxx:2891
 TFile.cxx:2892
 TFile.cxx:2893
 TFile.cxx:2894
 TFile.cxx:2895
 TFile.cxx:2896
 TFile.cxx:2897
 TFile.cxx:2898
 TFile.cxx:2899
 TFile.cxx:2900
 TFile.cxx:2901
 TFile.cxx:2902
 TFile.cxx:2903
 TFile.cxx:2904
 TFile.cxx:2905
 TFile.cxx:2906
 TFile.cxx:2907
 TFile.cxx:2908
 TFile.cxx:2909
 TFile.cxx:2910
 TFile.cxx:2911
 TFile.cxx:2912
 TFile.cxx:2913
 TFile.cxx:2914
 TFile.cxx:2915
 TFile.cxx:2916
 TFile.cxx:2917
 TFile.cxx:2918
 TFile.cxx:2919
 TFile.cxx:2920
 TFile.cxx:2921
 TFile.cxx:2922
 TFile.cxx:2923
 TFile.cxx:2924
 TFile.cxx:2925
 TFile.cxx:2926
 TFile.cxx:2927
 TFile.cxx:2928
 TFile.cxx:2929
 TFile.cxx:2930
 TFile.cxx:2931
 TFile.cxx:2932
 TFile.cxx:2933
 TFile.cxx:2934
 TFile.cxx:2935
 TFile.cxx:2936
 TFile.cxx:2937
 TFile.cxx:2938
 TFile.cxx:2939
 TFile.cxx:2940
 TFile.cxx:2941
 TFile.cxx:2942
 TFile.cxx:2943
 TFile.cxx:2944
 TFile.cxx:2945
 TFile.cxx:2946
 TFile.cxx:2947
 TFile.cxx:2948
 TFile.cxx:2949
 TFile.cxx:2950
 TFile.cxx:2951
 TFile.cxx:2952
 TFile.cxx:2953
 TFile.cxx:2954
 TFile.cxx:2955
 TFile.cxx:2956
 TFile.cxx:2957
 TFile.cxx:2958
 TFile.cxx:2959
 TFile.cxx:2960
 TFile.cxx:2961
 TFile.cxx:2962
 TFile.cxx:2963
 TFile.cxx:2964
 TFile.cxx:2965
 TFile.cxx:2966
 TFile.cxx:2967
 TFile.cxx:2968
 TFile.cxx:2969
 TFile.cxx:2970
 TFile.cxx:2971
 TFile.cxx:2972
 TFile.cxx:2973
 TFile.cxx:2974
 TFile.cxx:2975
 TFile.cxx:2976
 TFile.cxx:2977
 TFile.cxx:2978
 TFile.cxx:2979
 TFile.cxx:2980
 TFile.cxx:2981
 TFile.cxx:2982
 TFile.cxx:2983
 TFile.cxx:2984
 TFile.cxx:2985
 TFile.cxx:2986
 TFile.cxx:2987
 TFile.cxx:2988
 TFile.cxx:2989
 TFile.cxx:2990
 TFile.cxx:2991
 TFile.cxx:2992
 TFile.cxx:2993
 TFile.cxx:2994
 TFile.cxx:2995
 TFile.cxx:2996
 TFile.cxx:2997
 TFile.cxx:2998
 TFile.cxx:2999
 TFile.cxx:3000
 TFile.cxx:3001
 TFile.cxx:3002
 TFile.cxx:3003
 TFile.cxx:3004
 TFile.cxx:3005
 TFile.cxx:3006
 TFile.cxx:3007
 TFile.cxx:3008
 TFile.cxx:3009
 TFile.cxx:3010
 TFile.cxx:3011
 TFile.cxx:3012
 TFile.cxx:3013
 TFile.cxx:3014
 TFile.cxx:3015
 TFile.cxx:3016
 TFile.cxx:3017
 TFile.cxx:3018
 TFile.cxx:3019
 TFile.cxx:3020
 TFile.cxx:3021
 TFile.cxx:3022
 TFile.cxx:3023
 TFile.cxx:3024
 TFile.cxx:3025
 TFile.cxx:3026
 TFile.cxx:3027
 TFile.cxx:3028
 TFile.cxx:3029
 TFile.cxx:3030
 TFile.cxx:3031
 TFile.cxx:3032
 TFile.cxx:3033
 TFile.cxx:3034
 TFile.cxx:3035
 TFile.cxx:3036
 TFile.cxx:3037
 TFile.cxx:3038
 TFile.cxx:3039
 TFile.cxx:3040
 TFile.cxx:3041
 TFile.cxx:3042
 TFile.cxx:3043
 TFile.cxx:3044
 TFile.cxx:3045
 TFile.cxx:3046
 TFile.cxx:3047
 TFile.cxx:3048
 TFile.cxx:3049
 TFile.cxx:3050
 TFile.cxx:3051
 TFile.cxx:3052
 TFile.cxx:3053
 TFile.cxx:3054
 TFile.cxx:3055
 TFile.cxx:3056
 TFile.cxx:3057
 TFile.cxx:3058
 TFile.cxx:3059
 TFile.cxx:3060
 TFile.cxx:3061
 TFile.cxx:3062
 TFile.cxx:3063
 TFile.cxx:3064
 TFile.cxx:3065
 TFile.cxx:3066
 TFile.cxx:3067
 TFile.cxx:3068
 TFile.cxx:3069
 TFile.cxx:3070
 TFile.cxx:3071
 TFile.cxx:3072
 TFile.cxx:3073
 TFile.cxx:3074
 TFile.cxx:3075
 TFile.cxx:3076
 TFile.cxx:3077
 TFile.cxx:3078
 TFile.cxx:3079
 TFile.cxx:3080
 TFile.cxx:3081
 TFile.cxx:3082
 TFile.cxx:3083
 TFile.cxx:3084
 TFile.cxx:3085
 TFile.cxx:3086
 TFile.cxx:3087
 TFile.cxx:3088
 TFile.cxx:3089
 TFile.cxx:3090
 TFile.cxx:3091
 TFile.cxx:3092
 TFile.cxx:3093
 TFile.cxx:3094
 TFile.cxx:3095
 TFile.cxx:3096
 TFile.cxx:3097
 TFile.cxx:3098
 TFile.cxx:3099
 TFile.cxx:3100
 TFile.cxx:3101
 TFile.cxx:3102
 TFile.cxx:3103
 TFile.cxx:3104
 TFile.cxx:3105
 TFile.cxx:3106
 TFile.cxx:3107
 TFile.cxx:3108
 TFile.cxx:3109
 TFile.cxx:3110
 TFile.cxx:3111
 TFile.cxx:3112
 TFile.cxx:3113
 TFile.cxx:3114
 TFile.cxx:3115
 TFile.cxx:3116
 TFile.cxx:3117
 TFile.cxx:3118
 TFile.cxx:3119
 TFile.cxx:3120
 TFile.cxx:3121
 TFile.cxx:3122
 TFile.cxx:3123
 TFile.cxx:3124
 TFile.cxx:3125
 TFile.cxx:3126
 TFile.cxx:3127
 TFile.cxx:3128
 TFile.cxx:3129
 TFile.cxx:3130
 TFile.cxx:3131
 TFile.cxx:3132
 TFile.cxx:3133
 TFile.cxx:3134
 TFile.cxx:3135
 TFile.cxx:3136
 TFile.cxx:3137
 TFile.cxx:3138
 TFile.cxx:3139
 TFile.cxx:3140
 TFile.cxx:3141
 TFile.cxx:3142
 TFile.cxx:3143
 TFile.cxx:3144
 TFile.cxx:3145
 TFile.cxx:3146
 TFile.cxx:3147
 TFile.cxx:3148
 TFile.cxx:3149
 TFile.cxx:3150
 TFile.cxx:3151
 TFile.cxx:3152
 TFile.cxx:3153
 TFile.cxx:3154
 TFile.cxx:3155
 TFile.cxx:3156
 TFile.cxx:3157
 TFile.cxx:3158
 TFile.cxx:3159
 TFile.cxx:3160
 TFile.cxx:3161
 TFile.cxx:3162
 TFile.cxx:3163
 TFile.cxx:3164
 TFile.cxx:3165
 TFile.cxx:3166
 TFile.cxx:3167
 TFile.cxx:3168
 TFile.cxx:3169
 TFile.cxx:3170
 TFile.cxx:3171
 TFile.cxx:3172
 TFile.cxx:3173
 TFile.cxx:3174
 TFile.cxx:3175
 TFile.cxx:3176
 TFile.cxx:3177
 TFile.cxx:3178
 TFile.cxx:3179
 TFile.cxx:3180
 TFile.cxx:3181
 TFile.cxx:3182
 TFile.cxx:3183
 TFile.cxx:3184
 TFile.cxx:3185
 TFile.cxx:3186
 TFile.cxx:3187
 TFile.cxx:3188
 TFile.cxx:3189
 TFile.cxx:3190
 TFile.cxx:3191
 TFile.cxx:3192
 TFile.cxx:3193
 TFile.cxx:3194
 TFile.cxx:3195
 TFile.cxx:3196
 TFile.cxx:3197
 TFile.cxx:3198
 TFile.cxx:3199
 TFile.cxx:3200
 TFile.cxx:3201
 TFile.cxx:3202
 TFile.cxx:3203
 TFile.cxx:3204
 TFile.cxx:3205
 TFile.cxx:3206
 TFile.cxx:3207
 TFile.cxx:3208
 TFile.cxx:3209
 TFile.cxx:3210
 TFile.cxx:3211
 TFile.cxx:3212
 TFile.cxx:3213
 TFile.cxx:3214
 TFile.cxx:3215
 TFile.cxx:3216
 TFile.cxx:3217
 TFile.cxx:3218
 TFile.cxx:3219
 TFile.cxx:3220
 TFile.cxx:3221
 TFile.cxx:3222
 TFile.cxx:3223
 TFile.cxx:3224
 TFile.cxx:3225
 TFile.cxx:3226
 TFile.cxx:3227
 TFile.cxx:3228
 TFile.cxx:3229
 TFile.cxx:3230
 TFile.cxx:3231
 TFile.cxx:3232
 TFile.cxx:3233
 TFile.cxx:3234
 TFile.cxx:3235
 TFile.cxx:3236
 TFile.cxx:3237
 TFile.cxx:3238
 TFile.cxx:3239
 TFile.cxx:3240
 TFile.cxx:3241
 TFile.cxx:3242
 TFile.cxx:3243
 TFile.cxx:3244
 TFile.cxx:3245
 TFile.cxx:3246
 TFile.cxx:3247
 TFile.cxx:3248
 TFile.cxx:3249
 TFile.cxx:3250
 TFile.cxx:3251
 TFile.cxx:3252
 TFile.cxx:3253
 TFile.cxx:3254
 TFile.cxx:3255
 TFile.cxx:3256
 TFile.cxx:3257
 TFile.cxx:3258
 TFile.cxx:3259
 TFile.cxx:3260
 TFile.cxx:3261
 TFile.cxx:3262
 TFile.cxx:3263
 TFile.cxx:3264
 TFile.cxx:3265
 TFile.cxx:3266
 TFile.cxx:3267
 TFile.cxx:3268
 TFile.cxx:3269
 TFile.cxx:3270
 TFile.cxx:3271
 TFile.cxx:3272
 TFile.cxx:3273
 TFile.cxx:3274
 TFile.cxx:3275
 TFile.cxx:3276
 TFile.cxx:3277
 TFile.cxx:3278
 TFile.cxx:3279
 TFile.cxx:3280
 TFile.cxx:3281
 TFile.cxx:3282
 TFile.cxx:3283
 TFile.cxx:3284
 TFile.cxx:3285
 TFile.cxx:3286
 TFile.cxx:3287
 TFile.cxx:3288
 TFile.cxx:3289
 TFile.cxx:3290
 TFile.cxx:3291
 TFile.cxx:3292
 TFile.cxx:3293
 TFile.cxx:3294
 TFile.cxx:3295
 TFile.cxx:3296
 TFile.cxx:3297
 TFile.cxx:3298
 TFile.cxx:3299
 TFile.cxx:3300
 TFile.cxx:3301
 TFile.cxx:3302
 TFile.cxx:3303
 TFile.cxx:3304
 TFile.cxx:3305
 TFile.cxx:3306
 TFile.cxx:3307
 TFile.cxx:3308
 TFile.cxx:3309
 TFile.cxx:3310
 TFile.cxx:3311
 TFile.cxx:3312
 TFile.cxx:3313
 TFile.cxx:3314
 TFile.cxx:3315
 TFile.cxx:3316
 TFile.cxx:3317
 TFile.cxx:3318
 TFile.cxx:3319
 TFile.cxx:3320
 TFile.cxx:3321
 TFile.cxx:3322
 TFile.cxx:3323
 TFile.cxx:3324
 TFile.cxx:3325
 TFile.cxx:3326
 TFile.cxx:3327
 TFile.cxx:3328
 TFile.cxx:3329
 TFile.cxx:3330
 TFile.cxx:3331
 TFile.cxx:3332
 TFile.cxx:3333
 TFile.cxx:3334
 TFile.cxx:3335
 TFile.cxx:3336
 TFile.cxx:3337
 TFile.cxx:3338
 TFile.cxx:3339
 TFile.cxx:3340
 TFile.cxx:3341
 TFile.cxx:3342
 TFile.cxx:3343
 TFile.cxx:3344
 TFile.cxx:3345
 TFile.cxx:3346
 TFile.cxx:3347
 TFile.cxx:3348
 TFile.cxx:3349
 TFile.cxx:3350
 TFile.cxx:3351
 TFile.cxx:3352
 TFile.cxx:3353
 TFile.cxx:3354
 TFile.cxx:3355
 TFile.cxx:3356
 TFile.cxx:3357
 TFile.cxx:3358
 TFile.cxx:3359
 TFile.cxx:3360
 TFile.cxx:3361
 TFile.cxx:3362
 TFile.cxx:3363
 TFile.cxx:3364
 TFile.cxx:3365
 TFile.cxx:3366
 TFile.cxx:3367
 TFile.cxx:3368
 TFile.cxx:3369
 TFile.cxx:3370
 TFile.cxx:3371
 TFile.cxx:3372
 TFile.cxx:3373
 TFile.cxx:3374
 TFile.cxx:3375
 TFile.cxx:3376
 TFile.cxx:3377
 TFile.cxx:3378
 TFile.cxx:3379
 TFile.cxx:3380
 TFile.cxx:3381
 TFile.cxx:3382
 TFile.cxx:3383
 TFile.cxx:3384
 TFile.cxx:3385
 TFile.cxx:3386
 TFile.cxx:3387
 TFile.cxx:3388
 TFile.cxx:3389
 TFile.cxx:3390
 TFile.cxx:3391
 TFile.cxx:3392
 TFile.cxx:3393
 TFile.cxx:3394
 TFile.cxx:3395
 TFile.cxx:3396
 TFile.cxx:3397
 TFile.cxx:3398
 TFile.cxx:3399
 TFile.cxx:3400
 TFile.cxx:3401
 TFile.cxx:3402
 TFile.cxx:3403
 TFile.cxx:3404
 TFile.cxx:3405
 TFile.cxx:3406
 TFile.cxx:3407
 TFile.cxx:3408
 TFile.cxx:3409
 TFile.cxx:3410
 TFile.cxx:3411
 TFile.cxx:3412
 TFile.cxx:3413
 TFile.cxx:3414
 TFile.cxx:3415
 TFile.cxx:3416
 TFile.cxx:3417
 TFile.cxx:3418
 TFile.cxx:3419
 TFile.cxx:3420
 TFile.cxx:3421
 TFile.cxx:3422
 TFile.cxx:3423
 TFile.cxx:3424
 TFile.cxx:3425
 TFile.cxx:3426
 TFile.cxx:3427
 TFile.cxx:3428
 TFile.cxx:3429
 TFile.cxx:3430
 TFile.cxx:3431
 TFile.cxx:3432
 TFile.cxx:3433
 TFile.cxx:3434
 TFile.cxx:3435
 TFile.cxx:3436
 TFile.cxx:3437
 TFile.cxx:3438
 TFile.cxx:3439
 TFile.cxx:3440
 TFile.cxx:3441
 TFile.cxx:3442
 TFile.cxx:3443
 TFile.cxx:3444
 TFile.cxx:3445
 TFile.cxx:3446
 TFile.cxx:3447
 TFile.cxx:3448
 TFile.cxx:3449
 TFile.cxx:3450
 TFile.cxx:3451
 TFile.cxx:3452
 TFile.cxx:3453
 TFile.cxx:3454
 TFile.cxx:3455
 TFile.cxx:3456
 TFile.cxx:3457
 TFile.cxx:3458
 TFile.cxx:3459
 TFile.cxx:3460
 TFile.cxx:3461
 TFile.cxx:3462
 TFile.cxx:3463
 TFile.cxx:3464
 TFile.cxx:3465
 TFile.cxx:3466
 TFile.cxx:3467
 TFile.cxx:3468
 TFile.cxx:3469
 TFile.cxx:3470
 TFile.cxx:3471
 TFile.cxx:3472
 TFile.cxx:3473
 TFile.cxx:3474
 TFile.cxx:3475
 TFile.cxx:3476
 TFile.cxx:3477
 TFile.cxx:3478
 TFile.cxx:3479
 TFile.cxx:3480
 TFile.cxx:3481
 TFile.cxx:3482
 TFile.cxx:3483
 TFile.cxx:3484
 TFile.cxx:3485
 TFile.cxx:3486
 TFile.cxx:3487
 TFile.cxx:3488
 TFile.cxx:3489
 TFile.cxx:3490
 TFile.cxx:3491
 TFile.cxx:3492
 TFile.cxx:3493
 TFile.cxx:3494
 TFile.cxx:3495
 TFile.cxx:3496
 TFile.cxx:3497
 TFile.cxx:3498
 TFile.cxx:3499
 TFile.cxx:3500
 TFile.cxx:3501
 TFile.cxx:3502
 TFile.cxx:3503
 TFile.cxx:3504
 TFile.cxx:3505
 TFile.cxx:3506
 TFile.cxx:3507
 TFile.cxx:3508
 TFile.cxx:3509
 TFile.cxx:3510
 TFile.cxx:3511
 TFile.cxx:3512
 TFile.cxx:3513
 TFile.cxx:3514
 TFile.cxx:3515
 TFile.cxx:3516
 TFile.cxx:3517
 TFile.cxx:3518
 TFile.cxx:3519
 TFile.cxx:3520
 TFile.cxx:3521
 TFile.cxx:3522
 TFile.cxx:3523
 TFile.cxx:3524
 TFile.cxx:3525
 TFile.cxx:3526
 TFile.cxx:3527
 TFile.cxx:3528
 TFile.cxx:3529
 TFile.cxx:3530
 TFile.cxx:3531
 TFile.cxx:3532
 TFile.cxx:3533
 TFile.cxx:3534
 TFile.cxx:3535
 TFile.cxx:3536
 TFile.cxx:3537
 TFile.cxx:3538
 TFile.cxx:3539
 TFile.cxx:3540
 TFile.cxx:3541
 TFile.cxx:3542
 TFile.cxx:3543
 TFile.cxx:3544
 TFile.cxx:3545
 TFile.cxx:3546
 TFile.cxx:3547
 TFile.cxx:3548
 TFile.cxx:3549
 TFile.cxx:3550
 TFile.cxx:3551
 TFile.cxx:3552
 TFile.cxx:3553
 TFile.cxx:3554
 TFile.cxx:3555
 TFile.cxx:3556
 TFile.cxx:3557
 TFile.cxx:3558
 TFile.cxx:3559
 TFile.cxx:3560
 TFile.cxx:3561
 TFile.cxx:3562
 TFile.cxx:3563
 TFile.cxx:3564
 TFile.cxx:3565
 TFile.cxx:3566
 TFile.cxx:3567
 TFile.cxx:3568
 TFile.cxx:3569
 TFile.cxx:3570
 TFile.cxx:3571
 TFile.cxx:3572
 TFile.cxx:3573
 TFile.cxx:3574
 TFile.cxx:3575
 TFile.cxx:3576
 TFile.cxx:3577
 TFile.cxx:3578
 TFile.cxx:3579
 TFile.cxx:3580
 TFile.cxx:3581
 TFile.cxx:3582
 TFile.cxx:3583
 TFile.cxx:3584
 TFile.cxx:3585
 TFile.cxx:3586
 TFile.cxx:3587
 TFile.cxx:3588
 TFile.cxx:3589
 TFile.cxx:3590
 TFile.cxx:3591
 TFile.cxx:3592
 TFile.cxx:3593
 TFile.cxx:3594
 TFile.cxx:3595
 TFile.cxx:3596
 TFile.cxx:3597
 TFile.cxx:3598
 TFile.cxx:3599
 TFile.cxx:3600
 TFile.cxx:3601
 TFile.cxx:3602
 TFile.cxx:3603
 TFile.cxx:3604
 TFile.cxx:3605
 TFile.cxx:3606
 TFile.cxx:3607
 TFile.cxx:3608
 TFile.cxx:3609
 TFile.cxx:3610
 TFile.cxx:3611
 TFile.cxx:3612
 TFile.cxx:3613
 TFile.cxx:3614
 TFile.cxx:3615
 TFile.cxx:3616
 TFile.cxx:3617
 TFile.cxx:3618
 TFile.cxx:3619
 TFile.cxx:3620
 TFile.cxx:3621
 TFile.cxx:3622
 TFile.cxx:3623
 TFile.cxx:3624
 TFile.cxx:3625
 TFile.cxx:3626
 TFile.cxx:3627
 TFile.cxx:3628
 TFile.cxx:3629
 TFile.cxx:3630
 TFile.cxx:3631
 TFile.cxx:3632
 TFile.cxx:3633
 TFile.cxx:3634
 TFile.cxx:3635
 TFile.cxx:3636
 TFile.cxx:3637
 TFile.cxx:3638
 TFile.cxx:3639
 TFile.cxx:3640
 TFile.cxx:3641
 TFile.cxx:3642
 TFile.cxx:3643
 TFile.cxx:3644
 TFile.cxx:3645
 TFile.cxx:3646
 TFile.cxx:3647
 TFile.cxx:3648
 TFile.cxx:3649
 TFile.cxx:3650
 TFile.cxx:3651
 TFile.cxx:3652
 TFile.cxx:3653
 TFile.cxx:3654
 TFile.cxx:3655
 TFile.cxx:3656
 TFile.cxx:3657
 TFile.cxx:3658
 TFile.cxx:3659
 TFile.cxx:3660
 TFile.cxx:3661
 TFile.cxx:3662
 TFile.cxx:3663
 TFile.cxx:3664
 TFile.cxx:3665
 TFile.cxx:3666
 TFile.cxx:3667
 TFile.cxx:3668
 TFile.cxx:3669
 TFile.cxx:3670
 TFile.cxx:3671
 TFile.cxx:3672
 TFile.cxx:3673
 TFile.cxx:3674
 TFile.cxx:3675
 TFile.cxx:3676
 TFile.cxx:3677
 TFile.cxx:3678
 TFile.cxx:3679
 TFile.cxx:3680
 TFile.cxx:3681
 TFile.cxx:3682
 TFile.cxx:3683
 TFile.cxx:3684
 TFile.cxx:3685
 TFile.cxx:3686
 TFile.cxx:3687
 TFile.cxx:3688
 TFile.cxx:3689
 TFile.cxx:3690
 TFile.cxx:3691
 TFile.cxx:3692
 TFile.cxx:3693
 TFile.cxx:3694
 TFile.cxx:3695
 TFile.cxx:3696
 TFile.cxx:3697
 TFile.cxx:3698
 TFile.cxx:3699
 TFile.cxx:3700
 TFile.cxx:3701
 TFile.cxx:3702
 TFile.cxx:3703
 TFile.cxx:3704
 TFile.cxx:3705
 TFile.cxx:3706
 TFile.cxx:3707
 TFile.cxx:3708
 TFile.cxx:3709
 TFile.cxx:3710
 TFile.cxx:3711
 TFile.cxx:3712
 TFile.cxx:3713
 TFile.cxx:3714
 TFile.cxx:3715
 TFile.cxx:3716
 TFile.cxx:3717
 TFile.cxx:3718
 TFile.cxx:3719
 TFile.cxx:3720
 TFile.cxx:3721
 TFile.cxx:3722
 TFile.cxx:3723
 TFile.cxx:3724
 TFile.cxx:3725
 TFile.cxx:3726
 TFile.cxx:3727
 TFile.cxx:3728
 TFile.cxx:3729
 TFile.cxx:3730
 TFile.cxx:3731
 TFile.cxx:3732
 TFile.cxx:3733
 TFile.cxx:3734
 TFile.cxx:3735
 TFile.cxx:3736
 TFile.cxx:3737
 TFile.cxx:3738
 TFile.cxx:3739
 TFile.cxx:3740
 TFile.cxx:3741
 TFile.cxx:3742
 TFile.cxx:3743
 TFile.cxx:3744
 TFile.cxx:3745
 TFile.cxx:3746
 TFile.cxx:3747
 TFile.cxx:3748
 TFile.cxx:3749
 TFile.cxx:3750
 TFile.cxx:3751
 TFile.cxx:3752
 TFile.cxx:3753
 TFile.cxx:3754
 TFile.cxx:3755
 TFile.cxx:3756
 TFile.cxx:3757
 TFile.cxx:3758
 TFile.cxx:3759
 TFile.cxx:3760
 TFile.cxx:3761
 TFile.cxx:3762
 TFile.cxx:3763
 TFile.cxx:3764
 TFile.cxx:3765
 TFile.cxx:3766
 TFile.cxx:3767
 TFile.cxx:3768
 TFile.cxx:3769
 TFile.cxx:3770
 TFile.cxx:3771
 TFile.cxx:3772
 TFile.cxx:3773
 TFile.cxx:3774
 TFile.cxx:3775
 TFile.cxx:3776
 TFile.cxx:3777
 TFile.cxx:3778
 TFile.cxx:3779
 TFile.cxx:3780
 TFile.cxx:3781
 TFile.cxx:3782
 TFile.cxx:3783
 TFile.cxx:3784
 TFile.cxx:3785
 TFile.cxx:3786
 TFile.cxx:3787
 TFile.cxx:3788
 TFile.cxx:3789
 TFile.cxx:3790
 TFile.cxx:3791
 TFile.cxx:3792
 TFile.cxx:3793
 TFile.cxx:3794
 TFile.cxx:3795
 TFile.cxx:3796
 TFile.cxx:3797
 TFile.cxx:3798
 TFile.cxx:3799
 TFile.cxx:3800
 TFile.cxx:3801
 TFile.cxx:3802
 TFile.cxx:3803
 TFile.cxx:3804
 TFile.cxx:3805
 TFile.cxx:3806
 TFile.cxx:3807
 TFile.cxx:3808
 TFile.cxx:3809
 TFile.cxx:3810
 TFile.cxx:3811
 TFile.cxx:3812
 TFile.cxx:3813
 TFile.cxx:3814
 TFile.cxx:3815
 TFile.cxx:3816
 TFile.cxx:3817
 TFile.cxx:3818
 TFile.cxx:3819
 TFile.cxx:3820
 TFile.cxx:3821
 TFile.cxx:3822
 TFile.cxx:3823
 TFile.cxx:3824
 TFile.cxx:3825
 TFile.cxx:3826
 TFile.cxx:3827
 TFile.cxx:3828
 TFile.cxx:3829
 TFile.cxx:3830
 TFile.cxx:3831
 TFile.cxx:3832
 TFile.cxx:3833
 TFile.cxx:3834
 TFile.cxx:3835
 TFile.cxx:3836
 TFile.cxx:3837
 TFile.cxx:3838
 TFile.cxx:3839
 TFile.cxx:3840
 TFile.cxx:3841
 TFile.cxx:3842
 TFile.cxx:3843
 TFile.cxx:3844
 TFile.cxx:3845
 TFile.cxx:3846
 TFile.cxx:3847
 TFile.cxx:3848
 TFile.cxx:3849
 TFile.cxx:3850
 TFile.cxx:3851
 TFile.cxx:3852
 TFile.cxx:3853
 TFile.cxx:3854
 TFile.cxx:3855
 TFile.cxx:3856
 TFile.cxx:3857
 TFile.cxx:3858
 TFile.cxx:3859
 TFile.cxx:3860
 TFile.cxx:3861
 TFile.cxx:3862
 TFile.cxx:3863
 TFile.cxx:3864
 TFile.cxx:3865
 TFile.cxx:3866
 TFile.cxx:3867
 TFile.cxx:3868
 TFile.cxx:3869
 TFile.cxx:3870
 TFile.cxx:3871
 TFile.cxx:3872
 TFile.cxx:3873
 TFile.cxx:3874
 TFile.cxx:3875
 TFile.cxx:3876
 TFile.cxx:3877
 TFile.cxx:3878
 TFile.cxx:3879
 TFile.cxx:3880
 TFile.cxx:3881
 TFile.cxx:3882
 TFile.cxx:3883
 TFile.cxx:3884
 TFile.cxx:3885
 TFile.cxx:3886
 TFile.cxx:3887
 TFile.cxx:3888
 TFile.cxx:3889
 TFile.cxx:3890
 TFile.cxx:3891
 TFile.cxx:3892
 TFile.cxx:3893
 TFile.cxx:3894
 TFile.cxx:3895
 TFile.cxx:3896
 TFile.cxx:3897
 TFile.cxx:3898
 TFile.cxx:3899
 TFile.cxx:3900
 TFile.cxx:3901
 TFile.cxx:3902
 TFile.cxx:3903
 TFile.cxx:3904
 TFile.cxx:3905
 TFile.cxx:3906
 TFile.cxx:3907
 TFile.cxx:3908
 TFile.cxx:3909
 TFile.cxx:3910
 TFile.cxx:3911
 TFile.cxx:3912
 TFile.cxx:3913
 TFile.cxx:3914
 TFile.cxx:3915
 TFile.cxx:3916
 TFile.cxx:3917
 TFile.cxx:3918
 TFile.cxx:3919
 TFile.cxx:3920
 TFile.cxx:3921
 TFile.cxx:3922
 TFile.cxx:3923
 TFile.cxx:3924
 TFile.cxx:3925
 TFile.cxx:3926
 TFile.cxx:3927
 TFile.cxx:3928
 TFile.cxx:3929
 TFile.cxx:3930
 TFile.cxx:3931
 TFile.cxx:3932
 TFile.cxx:3933
 TFile.cxx:3934
 TFile.cxx:3935
 TFile.cxx:3936
 TFile.cxx:3937
 TFile.cxx:3938
 TFile.cxx:3939
 TFile.cxx:3940
 TFile.cxx:3941
 TFile.cxx:3942
 TFile.cxx:3943
 TFile.cxx:3944
 TFile.cxx:3945
 TFile.cxx:3946
 TFile.cxx:3947
 TFile.cxx:3948
 TFile.cxx:3949
 TFile.cxx:3950
 TFile.cxx:3951
 TFile.cxx:3952
 TFile.cxx:3953
 TFile.cxx:3954
 TFile.cxx:3955
 TFile.cxx:3956
 TFile.cxx:3957
 TFile.cxx:3958
 TFile.cxx:3959
 TFile.cxx:3960
 TFile.cxx:3961
 TFile.cxx:3962
 TFile.cxx:3963
 TFile.cxx:3964
 TFile.cxx:3965
 TFile.cxx:3966
 TFile.cxx:3967
 TFile.cxx:3968
 TFile.cxx:3969
 TFile.cxx:3970
 TFile.cxx:3971
 TFile.cxx:3972
 TFile.cxx:3973
 TFile.cxx:3974
 TFile.cxx:3975
 TFile.cxx:3976
 TFile.cxx:3977
 TFile.cxx:3978
 TFile.cxx:3979
 TFile.cxx:3980
 TFile.cxx:3981
 TFile.cxx:3982
 TFile.cxx:3983
 TFile.cxx:3984
 TFile.cxx:3985
 TFile.cxx:3986
 TFile.cxx:3987
 TFile.cxx:3988
 TFile.cxx:3989
 TFile.cxx:3990
 TFile.cxx:3991
 TFile.cxx:3992
 TFile.cxx:3993
 TFile.cxx:3994
 TFile.cxx:3995
 TFile.cxx:3996
 TFile.cxx:3997
 TFile.cxx:3998
 TFile.cxx:3999
 TFile.cxx:4000
 TFile.cxx:4001
 TFile.cxx:4002
 TFile.cxx:4003
 TFile.cxx:4004
 TFile.cxx:4005
 TFile.cxx:4006
 TFile.cxx:4007
 TFile.cxx:4008
 TFile.cxx:4009
 TFile.cxx:4010
 TFile.cxx:4011
 TFile.cxx:4012
 TFile.cxx:4013
 TFile.cxx:4014
 TFile.cxx:4015
 TFile.cxx:4016
 TFile.cxx:4017
 TFile.cxx:4018
 TFile.cxx:4019
 TFile.cxx:4020
 TFile.cxx:4021
 TFile.cxx:4022
 TFile.cxx:4023
 TFile.cxx:4024
 TFile.cxx:4025
 TFile.cxx:4026
 TFile.cxx:4027
 TFile.cxx:4028
 TFile.cxx:4029
 TFile.cxx:4030
 TFile.cxx:4031
 TFile.cxx:4032
 TFile.cxx:4033
 TFile.cxx:4034
 TFile.cxx:4035
 TFile.cxx:4036
 TFile.cxx:4037
 TFile.cxx:4038
 TFile.cxx:4039
 TFile.cxx:4040
 TFile.cxx:4041
 TFile.cxx:4042
 TFile.cxx:4043
 TFile.cxx:4044
 TFile.cxx:4045
 TFile.cxx:4046
 TFile.cxx:4047
 TFile.cxx:4048
 TFile.cxx:4049
 TFile.cxx:4050
 TFile.cxx:4051
 TFile.cxx:4052
 TFile.cxx:4053
 TFile.cxx:4054
 TFile.cxx:4055
 TFile.cxx:4056
 TFile.cxx:4057
 TFile.cxx:4058
 TFile.cxx:4059
 TFile.cxx:4060
 TFile.cxx:4061
 TFile.cxx:4062
 TFile.cxx:4063
 TFile.cxx:4064
 TFile.cxx:4065
 TFile.cxx:4066
 TFile.cxx:4067
 TFile.cxx:4068
 TFile.cxx:4069
 TFile.cxx:4070
 TFile.cxx:4071
 TFile.cxx:4072
 TFile.cxx:4073
 TFile.cxx:4074
 TFile.cxx:4075
 TFile.cxx:4076
 TFile.cxx:4077
 TFile.cxx:4078
 TFile.cxx:4079
 TFile.cxx:4080
 TFile.cxx:4081
 TFile.cxx:4082
 TFile.cxx:4083
 TFile.cxx:4084
 TFile.cxx:4085
 TFile.cxx:4086
 TFile.cxx:4087
 TFile.cxx:4088
 TFile.cxx:4089
 TFile.cxx:4090
 TFile.cxx:4091
 TFile.cxx:4092
 TFile.cxx:4093
 TFile.cxx:4094
 TFile.cxx:4095
 TFile.cxx:4096
 TFile.cxx:4097
 TFile.cxx:4098
 TFile.cxx:4099
 TFile.cxx:4100
 TFile.cxx:4101
 TFile.cxx:4102
 TFile.cxx:4103
 TFile.cxx:4104
 TFile.cxx:4105
 TFile.cxx:4106
 TFile.cxx:4107
 TFile.cxx:4108
 TFile.cxx:4109
 TFile.cxx:4110
 TFile.cxx:4111
 TFile.cxx:4112
 TFile.cxx:4113
 TFile.cxx:4114
 TFile.cxx:4115
 TFile.cxx:4116
 TFile.cxx:4117
 TFile.cxx:4118
 TFile.cxx:4119
 TFile.cxx:4120
 TFile.cxx:4121
 TFile.cxx:4122
 TFile.cxx:4123
 TFile.cxx:4124
 TFile.cxx:4125
 TFile.cxx:4126
 TFile.cxx:4127
 TFile.cxx:4128
 TFile.cxx:4129
 TFile.cxx:4130
 TFile.cxx:4131
 TFile.cxx:4132
 TFile.cxx:4133
 TFile.cxx:4134
 TFile.cxx:4135
 TFile.cxx:4136
 TFile.cxx:4137
 TFile.cxx:4138
 TFile.cxx:4139
 TFile.cxx:4140
 TFile.cxx:4141
 TFile.cxx:4142
 TFile.cxx:4143
 TFile.cxx:4144
 TFile.cxx:4145
 TFile.cxx:4146
 TFile.cxx:4147
 TFile.cxx:4148
 TFile.cxx:4149
 TFile.cxx:4150
 TFile.cxx:4151
 TFile.cxx:4152
 TFile.cxx:4153
 TFile.cxx:4154
 TFile.cxx:4155
 TFile.cxx:4156
 TFile.cxx:4157
 TFile.cxx:4158
 TFile.cxx:4159
 TFile.cxx:4160
 TFile.cxx:4161
 TFile.cxx:4162
 TFile.cxx:4163
 TFile.cxx:4164
 TFile.cxx:4165
 TFile.cxx:4166
 TFile.cxx:4167
 TFile.cxx:4168
 TFile.cxx:4169
 TFile.cxx:4170
 TFile.cxx:4171
 TFile.cxx:4172
 TFile.cxx:4173
 TFile.cxx:4174
 TFile.cxx:4175
 TFile.cxx:4176
 TFile.cxx:4177
 TFile.cxx:4178
 TFile.cxx:4179
 TFile.cxx:4180
 TFile.cxx:4181
 TFile.cxx:4182
 TFile.cxx:4183
 TFile.cxx:4184
 TFile.cxx:4185
 TFile.cxx:4186
 TFile.cxx:4187
 TFile.cxx:4188
 TFile.cxx:4189
 TFile.cxx:4190
 TFile.cxx:4191
 TFile.cxx:4192
 TFile.cxx:4193
 TFile.cxx:4194
 TFile.cxx:4195
 TFile.cxx:4196
 TFile.cxx:4197
 TFile.cxx:4198
 TFile.cxx:4199
 TFile.cxx:4200
 TFile.cxx:4201
 TFile.cxx:4202
 TFile.cxx:4203
 TFile.cxx:4204
 TFile.cxx:4205
 TFile.cxx:4206
 TFile.cxx:4207
 TFile.cxx:4208
 TFile.cxx:4209
 TFile.cxx:4210
 TFile.cxx:4211
 TFile.cxx:4212
 TFile.cxx:4213
 TFile.cxx:4214
 TFile.cxx:4215
 TFile.cxx:4216
 TFile.cxx:4217
 TFile.cxx:4218
 TFile.cxx:4219
 TFile.cxx:4220
 TFile.cxx:4221
 TFile.cxx:4222
 TFile.cxx:4223
 TFile.cxx:4224
 TFile.cxx:4225
 TFile.cxx:4226
 TFile.cxx:4227
 TFile.cxx:4228
 TFile.cxx:4229
 TFile.cxx:4230
 TFile.cxx:4231
 TFile.cxx:4232
 TFile.cxx:4233
 TFile.cxx:4234
 TFile.cxx:4235
 TFile.cxx:4236
 TFile.cxx:4237
 TFile.cxx:4238
 TFile.cxx:4239
 TFile.cxx:4240
 TFile.cxx:4241
 TFile.cxx:4242
 TFile.cxx:4243
 TFile.cxx:4244
 TFile.cxx:4245
 TFile.cxx:4246
 TFile.cxx:4247
 TFile.cxx:4248
 TFile.cxx:4249
 TFile.cxx:4250
 TFile.cxx:4251
 TFile.cxx:4252
 TFile.cxx:4253
 TFile.cxx:4254
 TFile.cxx:4255
 TFile.cxx:4256
 TFile.cxx:4257
 TFile.cxx:4258
 TFile.cxx:4259
 TFile.cxx:4260
 TFile.cxx:4261
 TFile.cxx:4262
 TFile.cxx:4263
 TFile.cxx:4264
 TFile.cxx:4265
 TFile.cxx:4266
 TFile.cxx:4267
 TFile.cxx:4268
 TFile.cxx:4269
 TFile.cxx:4270
 TFile.cxx:4271
 TFile.cxx:4272
 TFile.cxx:4273
 TFile.cxx:4274
 TFile.cxx:4275
 TFile.cxx:4276
 TFile.cxx:4277
 TFile.cxx:4278
 TFile.cxx:4279
 TFile.cxx:4280
 TFile.cxx:4281
 TFile.cxx:4282
 TFile.cxx:4283
 TFile.cxx:4284
 TFile.cxx:4285
 TFile.cxx:4286
 TFile.cxx:4287
 TFile.cxx:4288
 TFile.cxx:4289
 TFile.cxx:4290
 TFile.cxx:4291
 TFile.cxx:4292
 TFile.cxx:4293
 TFile.cxx:4294
 TFile.cxx:4295
 TFile.cxx:4296
 TFile.cxx:4297
 TFile.cxx:4298
 TFile.cxx:4299
 TFile.cxx:4300
 TFile.cxx:4301
 TFile.cxx:4302
 TFile.cxx:4303
 TFile.cxx:4304
 TFile.cxx:4305
 TFile.cxx:4306
 TFile.cxx:4307
 TFile.cxx:4308
 TFile.cxx:4309
 TFile.cxx:4310
 TFile.cxx:4311
 TFile.cxx:4312
 TFile.cxx:4313
 TFile.cxx:4314
 TFile.cxx:4315
 TFile.cxx:4316
 TFile.cxx:4317
 TFile.cxx:4318
 TFile.cxx:4319
 TFile.cxx:4320
 TFile.cxx:4321
 TFile.cxx:4322
 TFile.cxx:4323
 TFile.cxx:4324
 TFile.cxx:4325
 TFile.cxx:4326
 TFile.cxx:4327
 TFile.cxx:4328
 TFile.cxx:4329
 TFile.cxx:4330
 TFile.cxx:4331
 TFile.cxx:4332
 TFile.cxx:4333
 TFile.cxx:4334
 TFile.cxx:4335
 TFile.cxx:4336
 TFile.cxx:4337
 TFile.cxx:4338
 TFile.cxx:4339
 TFile.cxx:4340
 TFile.cxx:4341
 TFile.cxx:4342
 TFile.cxx:4343
 TFile.cxx:4344
 TFile.cxx:4345
 TFile.cxx:4346
 TFile.cxx:4347
 TFile.cxx:4348
 TFile.cxx:4349
 TFile.cxx:4350
 TFile.cxx:4351
 TFile.cxx:4352
 TFile.cxx:4353
 TFile.cxx:4354
 TFile.cxx:4355
 TFile.cxx:4356
 TFile.cxx:4357
 TFile.cxx:4358
 TFile.cxx:4359
 TFile.cxx:4360
 TFile.cxx:4361
 TFile.cxx:4362
 TFile.cxx:4363
 TFile.cxx:4364
 TFile.cxx:4365
 TFile.cxx:4366
 TFile.cxx:4367
 TFile.cxx:4368
 TFile.cxx:4369
 TFile.cxx:4370
 TFile.cxx:4371
 TFile.cxx:4372
 TFile.cxx:4373
 TFile.cxx:4374
 TFile.cxx:4375
 TFile.cxx:4376
 TFile.cxx:4377
 TFile.cxx:4378
 TFile.cxx:4379
 TFile.cxx:4380
 TFile.cxx:4381
 TFile.cxx:4382
 TFile.cxx:4383
 TFile.cxx:4384
 TFile.cxx:4385
 TFile.cxx:4386
 TFile.cxx:4387
 TFile.cxx:4388
 TFile.cxx:4389
 TFile.cxx:4390
 TFile.cxx:4391
 TFile.cxx:4392
 TFile.cxx:4393
 TFile.cxx:4394
 TFile.cxx:4395
 TFile.cxx:4396
 TFile.cxx:4397
 TFile.cxx:4398
 TFile.cxx:4399
 TFile.cxx:4400
 TFile.cxx:4401
 TFile.cxx:4402
 TFile.cxx:4403
 TFile.cxx:4404
 TFile.cxx:4405
 TFile.cxx:4406
 TFile.cxx:4407
 TFile.cxx:4408
 TFile.cxx:4409
 TFile.cxx:4410
 TFile.cxx:4411
 TFile.cxx:4412
 TFile.cxx:4413
 TFile.cxx:4414
 TFile.cxx:4415
 TFile.cxx:4416
 TFile.cxx:4417
 TFile.cxx:4418
 TFile.cxx:4419
 TFile.cxx:4420
 TFile.cxx:4421
 TFile.cxx:4422
 TFile.cxx:4423
 TFile.cxx:4424
 TFile.cxx:4425
 TFile.cxx:4426
 TFile.cxx:4427
 TFile.cxx:4428
 TFile.cxx:4429
 TFile.cxx:4430
 TFile.cxx:4431
 TFile.cxx:4432
 TFile.cxx:4433
 TFile.cxx:4434
 TFile.cxx:4435
 TFile.cxx:4436
 TFile.cxx:4437
 TFile.cxx:4438
 TFile.cxx:4439
 TFile.cxx:4440
 TFile.cxx:4441
 TFile.cxx:4442
 TFile.cxx:4443
 TFile.cxx:4444
 TFile.cxx:4445
 TFile.cxx:4446
 TFile.cxx:4447
 TFile.cxx:4448
 TFile.cxx:4449
 TFile.cxx:4450
 TFile.cxx:4451
 TFile.cxx:4452
 TFile.cxx:4453
 TFile.cxx:4454
 TFile.cxx:4455
 TFile.cxx:4456
 TFile.cxx:4457
 TFile.cxx:4458
 TFile.cxx:4459
 TFile.cxx:4460
 TFile.cxx:4461
 TFile.cxx:4462
 TFile.cxx:4463
 TFile.cxx:4464
 TFile.cxx:4465
 TFile.cxx:4466
 TFile.cxx:4467
 TFile.cxx:4468
 TFile.cxx:4469
 TFile.cxx:4470
 TFile.cxx:4471
 TFile.cxx:4472
 TFile.cxx:4473
 TFile.cxx:4474
 TFile.cxx:4475
 TFile.cxx:4476
 TFile.cxx:4477
 TFile.cxx:4478
 TFile.cxx:4479
 TFile.cxx:4480
 TFile.cxx:4481
 TFile.cxx:4482
 TFile.cxx:4483
 TFile.cxx:4484
 TFile.cxx:4485
 TFile.cxx:4486
 TFile.cxx:4487
 TFile.cxx:4488
 TFile.cxx:4489
 TFile.cxx:4490
 TFile.cxx:4491
 TFile.cxx:4492
 TFile.cxx:4493
 TFile.cxx:4494
 TFile.cxx:4495
 TFile.cxx:4496
 TFile.cxx:4497
 TFile.cxx:4498
 TFile.cxx:4499
 TFile.cxx:4500
 TFile.cxx:4501
 TFile.cxx:4502
 TFile.cxx:4503
 TFile.cxx:4504
 TFile.cxx:4505
 TFile.cxx:4506
 TFile.cxx:4507
 TFile.cxx:4508
 TFile.cxx:4509
 TFile.cxx:4510
 TFile.cxx:4511
 TFile.cxx:4512
 TFile.cxx:4513
 TFile.cxx:4514
 TFile.cxx:4515
 TFile.cxx:4516
 TFile.cxx:4517
 TFile.cxx:4518
 TFile.cxx:4519
 TFile.cxx:4520
 TFile.cxx:4521
 TFile.cxx:4522
 TFile.cxx:4523
 TFile.cxx:4524
 TFile.cxx:4525
 TFile.cxx:4526
 TFile.cxx:4527
 TFile.cxx:4528
 TFile.cxx:4529
 TFile.cxx:4530
 TFile.cxx:4531
 TFile.cxx:4532
 TFile.cxx:4533
 TFile.cxx:4534
 TFile.cxx:4535
 TFile.cxx:4536
 TFile.cxx:4537
 TFile.cxx:4538
 TFile.cxx:4539
 TFile.cxx:4540
 TFile.cxx:4541
 TFile.cxx:4542
 TFile.cxx:4543
 TFile.cxx:4544
 TFile.cxx:4545
 TFile.cxx:4546
 TFile.cxx:4547
 TFile.cxx:4548
 TFile.cxx:4549
 TFile.cxx:4550
 TFile.cxx:4551
 TFile.cxx:4552
 TFile.cxx:4553
 TFile.cxx:4554
 TFile.cxx:4555
 TFile.cxx:4556
 TFile.cxx:4557
 TFile.cxx:4558
 TFile.cxx:4559
 TFile.cxx:4560
 TFile.cxx:4561
 TFile.cxx:4562
 TFile.cxx:4563
 TFile.cxx:4564
 TFile.cxx:4565
 TFile.cxx:4566
 TFile.cxx:4567
 TFile.cxx:4568
 TFile.cxx:4569
 TFile.cxx:4570
 TFile.cxx:4571
 TFile.cxx:4572
 TFile.cxx:4573
 TFile.cxx:4574
 TFile.cxx:4575
 TFile.cxx:4576
 TFile.cxx:4577
 TFile.cxx:4578
 TFile.cxx:4579
 TFile.cxx:4580
 TFile.cxx:4581
 TFile.cxx:4582
 TFile.cxx:4583
 TFile.cxx:4584
 TFile.cxx:4585
 TFile.cxx:4586
 TFile.cxx:4587
 TFile.cxx:4588
 TFile.cxx:4589
 TFile.cxx:4590
 TFile.cxx:4591
 TFile.cxx:4592
 TFile.cxx:4593
 TFile.cxx:4594
 TFile.cxx:4595
 TFile.cxx:4596
 TFile.cxx:4597
 TFile.cxx:4598
 TFile.cxx:4599
 TFile.cxx:4600
 TFile.cxx:4601
 TFile.cxx:4602
 TFile.cxx:4603
 TFile.cxx:4604
 TFile.cxx:4605
 TFile.cxx:4606
 TFile.cxx:4607
 TFile.cxx:4608
 TFile.cxx:4609
 TFile.cxx:4610
 TFile.cxx:4611
 TFile.cxx:4612
 TFile.cxx:4613
 TFile.cxx:4614
 TFile.cxx:4615
 TFile.cxx:4616
 TFile.cxx:4617
 TFile.cxx:4618
 TFile.cxx:4619
 TFile.cxx:4620
 TFile.cxx:4621
 TFile.cxx:4622
 TFile.cxx:4623
 TFile.cxx:4624
 TFile.cxx:4625
 TFile.cxx:4626
 TFile.cxx:4627
 TFile.cxx:4628
 TFile.cxx:4629
 TFile.cxx:4630
 TFile.cxx:4631
 TFile.cxx:4632
 TFile.cxx:4633
 TFile.cxx:4634
 TFile.cxx:4635
 TFile.cxx:4636
 TFile.cxx:4637
 TFile.cxx:4638
 TFile.cxx:4639
 TFile.cxx:4640
 TFile.cxx:4641
 TFile.cxx:4642
 TFile.cxx:4643
 TFile.cxx:4644
 TFile.cxx:4645
 TFile.cxx:4646
 TFile.cxx:4647
 TFile.cxx:4648
 TFile.cxx:4649
 TFile.cxx:4650
 TFile.cxx:4651
 TFile.cxx:4652
 TFile.cxx:4653
 TFile.cxx:4654
 TFile.cxx:4655
 TFile.cxx:4656
 TFile.cxx:4657
 TFile.cxx:4658
 TFile.cxx:4659
 TFile.cxx:4660
 TFile.cxx:4661
 TFile.cxx:4662
 TFile.cxx:4663
 TFile.cxx:4664
 TFile.cxx:4665
 TFile.cxx:4666
 TFile.cxx:4667
 TFile.cxx:4668
 TFile.cxx:4669
 TFile.cxx:4670
 TFile.cxx:4671
 TFile.cxx:4672
 TFile.cxx:4673
 TFile.cxx:4674
 TFile.cxx:4675
 TFile.cxx:4676
 TFile.cxx:4677
 TFile.cxx:4678
 TFile.cxx:4679
 TFile.cxx:4680
 TFile.cxx:4681
 TFile.cxx:4682
 TFile.cxx:4683
 TFile.cxx:4684
 TFile.cxx:4685
 TFile.cxx:4686
 TFile.cxx:4687
 TFile.cxx:4688
 TFile.cxx:4689
 TFile.cxx:4690
 TFile.cxx:4691
 TFile.cxx:4692
 TFile.cxx:4693
 TFile.cxx:4694
 TFile.cxx:4695
 TFile.cxx:4696
 TFile.cxx:4697
 TFile.cxx:4698
 TFile.cxx:4699
 TFile.cxx:4700
 TFile.cxx:4701
 TFile.cxx:4702
 TFile.cxx:4703
 TFile.cxx:4704
 TFile.cxx:4705
 TFile.cxx:4706
 TFile.cxx:4707
 TFile.cxx:4708
 TFile.cxx:4709
 TFile.cxx:4710
 TFile.cxx:4711
 TFile.cxx:4712
 TFile.cxx:4713
 TFile.cxx:4714
 TFile.cxx:4715
 TFile.cxx:4716
 TFile.cxx:4717
 TFile.cxx:4718
 TFile.cxx:4719
 TFile.cxx:4720
 TFile.cxx:4721
 TFile.cxx:4722
 TFile.cxx:4723
 TFile.cxx:4724
 TFile.cxx:4725
 TFile.cxx:4726
 TFile.cxx:4727
 TFile.cxx:4728
 TFile.cxx:4729
 TFile.cxx:4730
 TFile.cxx:4731
 TFile.cxx:4732
 TFile.cxx:4733
 TFile.cxx:4734
 TFile.cxx:4735
 TFile.cxx:4736
 TFile.cxx:4737
 TFile.cxx:4738
 TFile.cxx:4739
 TFile.cxx:4740
 TFile.cxx:4741
 TFile.cxx:4742
 TFile.cxx:4743
 TFile.cxx:4744
 TFile.cxx:4745
 TFile.cxx:4746
 TFile.cxx:4747
 TFile.cxx:4748
 TFile.cxx:4749
 TFile.cxx:4750
 TFile.cxx:4751
 TFile.cxx:4752
 TFile.cxx:4753
 TFile.cxx:4754
 TFile.cxx:4755
 TFile.cxx:4756
 TFile.cxx:4757
 TFile.cxx:4758
 TFile.cxx:4759
 TFile.cxx:4760
 TFile.cxx:4761
 TFile.cxx:4762
 TFile.cxx:4763
 TFile.cxx:4764
 TFile.cxx:4765
 TFile.cxx:4766
 TFile.cxx:4767
 TFile.cxx:4768
 TFile.cxx:4769
 TFile.cxx:4770
 TFile.cxx:4771
 TFile.cxx:4772
 TFile.cxx:4773
 TFile.cxx:4774
 TFile.cxx:4775
 TFile.cxx:4776
 TFile.cxx:4777
 TFile.cxx:4778
 TFile.cxx:4779
 TFile.cxx:4780
 TFile.cxx:4781
 TFile.cxx:4782
 TFile.cxx:4783
 TFile.cxx:4784
 TFile.cxx:4785
 TFile.cxx:4786
 TFile.cxx:4787
 TFile.cxx:4788
 TFile.cxx:4789
 TFile.cxx:4790
 TFile.cxx:4791
 TFile.cxx:4792
 TFile.cxx:4793
 TFile.cxx:4794
 TFile.cxx:4795
 TFile.cxx:4796
 TFile.cxx:4797
 TFile.cxx:4798
 TFile.cxx:4799
 TFile.cxx:4800
 TFile.cxx:4801
 TFile.cxx:4802
 TFile.cxx:4803
 TFile.cxx:4804
 TFile.cxx:4805
 TFile.cxx:4806
 TFile.cxx:4807
 TFile.cxx:4808
 TFile.cxx:4809
 TFile.cxx:4810
 TFile.cxx:4811
 TFile.cxx:4812
 TFile.cxx:4813
 TFile.cxx:4814
 TFile.cxx:4815
 TFile.cxx:4816
 TFile.cxx:4817
 TFile.cxx:4818
 TFile.cxx:4819
 TFile.cxx:4820
 TFile.cxx:4821
 TFile.cxx:4822
 TFile.cxx:4823
 TFile.cxx:4824
 TFile.cxx:4825
 TFile.cxx:4826
 TFile.cxx:4827
 TFile.cxx:4828
 TFile.cxx:4829
 TFile.cxx:4830
 TFile.cxx:4831
 TFile.cxx:4832
 TFile.cxx:4833
 TFile.cxx:4834
 TFile.cxx:4835
 TFile.cxx:4836
 TFile.cxx:4837
 TFile.cxx:4838
 TFile.cxx:4839
 TFile.cxx:4840
 TFile.cxx:4841
 TFile.cxx:4842
 TFile.cxx:4843
 TFile.cxx:4844
 TFile.cxx:4845
 TFile.cxx:4846
 TFile.cxx:4847
 TFile.cxx:4848
 TFile.cxx:4849
 TFile.cxx:4850
 TFile.cxx:4851
 TFile.cxx:4852
 TFile.cxx:4853
 TFile.cxx:4854
 TFile.cxx:4855
 TFile.cxx:4856
 TFile.cxx:4857
 TFile.cxx:4858
 TFile.cxx:4859
 TFile.cxx:4860
 TFile.cxx:4861
 TFile.cxx:4862
 TFile.cxx:4863
 TFile.cxx:4864
 TFile.cxx:4865
 TFile.cxx:4866
 TFile.cxx:4867
 TFile.cxx:4868
 TFile.cxx:4869
 TFile.cxx:4870
 TFile.cxx:4871
 TFile.cxx:4872
 TFile.cxx:4873
 TFile.cxx:4874
 TFile.cxx:4875
 TFile.cxx:4876
 TFile.cxx:4877
 TFile.cxx:4878
 TFile.cxx:4879
 TFile.cxx:4880
 TFile.cxx:4881
 TFile.cxx:4882
 TFile.cxx:4883
 TFile.cxx:4884
 TFile.cxx:4885
 TFile.cxx:4886
 TFile.cxx:4887
 TFile.cxx:4888
 TFile.cxx:4889
 TFile.cxx:4890
 TFile.cxx:4891
 TFile.cxx:4892
 TFile.cxx:4893
 TFile.cxx:4894
 TFile.cxx:4895
 TFile.cxx:4896
 TFile.cxx:4897
 TFile.cxx:4898
 TFile.cxx:4899
 TFile.cxx:4900
 TFile.cxx:4901
 TFile.cxx:4902
 TFile.cxx:4903
 TFile.cxx:4904
 TFile.cxx:4905
 TFile.cxx:4906
 TFile.cxx:4907
 TFile.cxx:4908
 TFile.cxx:4909
 TFile.cxx:4910
 TFile.cxx:4911
 TFile.cxx:4912
 TFile.cxx:4913
 TFile.cxx:4914
 TFile.cxx:4915
 TFile.cxx:4916
 TFile.cxx:4917
 TFile.cxx:4918
 TFile.cxx:4919
 TFile.cxx:4920
 TFile.cxx:4921
 TFile.cxx:4922
 TFile.cxx:4923
 TFile.cxx:4924
 TFile.cxx:4925
 TFile.cxx:4926
 TFile.cxx:4927
 TFile.cxx:4928