ROOT logo
// @(#)root/proof:$Id: TDSet.cxx 27898 2009-03-20 13:57:18Z ganis $
// Author: Fons Rademakers   11/01/02

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

//////////////////////////////////////////////////////////////////////////
//                                                                      //
// TDSet                                                                //
//                                                                      //
// This class implements a data set to be used for PROOF processing.    //
// The TDSet defines the class of which objects will be processed,      //
// the directory in the file where the objects of that type can be      //
// found and the list of files to be processed. The files can be        //
// specified as logical file names (LFN's) or as physical file names    //
// (PFN's). In case of LFN's the resolution to PFN's will be done       //
// according to the currently active GRID interface.                    //
// Examples:                                                            //
//   TDSet treeset("TTree", "AOD");                                     //
//   treeset.Add("lfn:/alien.cern.ch/alice/prod2002/file1");            //
//   ...                                                                //
//   treeset.AddFriend(friendset);                                      //
//                                                                      //
// or                                                                   //
//                                                                      //
//   TDSet objset("MyEvent", "*", "/events");                           //
//   objset.Add("root://cms.cern.ch/user/prod2002/hprod_1.root");       //
//   ...                                                                //
//   objset.Add(set2003);                                               //
//                                                                      //
// Validity of file names will only be checked at processing time       //
// (typically on the PROOF master server), not at creation time.        //
//                                                                      //
//////////////////////////////////////////////////////////////////////////

#include "TDSet.h"

#include "Riostream.h"
#include "TClass.h"
#include "TClassTable.h"
#include "TCut.h"
#include "TError.h"
#include "TEntryList.h"
#include "TEnv.h"
#include "TEventList.h"
#include "TFile.h"
#include "TFileInfo.h"
#include "TFileStager.h"
#include "TFriendElement.h"
#include "TKey.h"
#include "THashList.h"
#include "TMap.h"
#include "TROOT.h"
#include "TTimeStamp.h"
#include "TTree.h"
#include "TUrl.h"
#include "TRegexp.h"
#include "TVirtualPerfStats.h"
#include "TProof.h"
#include "TProofChain.h"
#include "TProofServ.h"
#include "TPluginManager.h"
#include "TChain.h"
#include "TChainElement.h"
#include "TSystem.h"
#include "THashList.h"

#include "TVirtualStreamerInfo.h"
#include "TClassRef.h"

ClassImp(TDSetElement)
ClassImp(TDSet)

//______________________________________________________________________________
TDSetElement::TDSetElement() : TNamed("",""),
                               fDirectory(),
                               fFirst(0),
                               fNum(0),
                               fMsd(),
                               fTDSetOffset(0),
                               fEntryList(0),
                               fValid(kFALSE),
                               fEntries(0),
                               fFriends(0)
{
   // Default constructor
   ResetBit(kWriteV3);
   ResetBit(kHasBeenLookedUp);
   ResetBit(kEmpty);
   ResetBit(kCorrupted);
}

//______________________________________________________________________________
TDSetElement::TDSetElement(const char *file, const char *objname, const char *dir,
                           Long64_t first, Long64_t num,
                           const char *msd) : TNamed(file, objname)
{
   // Create a TDSet element.

   if (first < 0) {
      Warning("TDSetElement", "first must be >= 0, %lld is not allowed - setting to 0", first);
      fFirst = 0;
   } else {
      fFirst = first;
   }
   if (num < -1) {
      Warning("TDSetElement", "num must be >= -1, %lld is not allowed - setting to -1", num);
      fNum   = -1;
   } else {
      fNum   = num;
   }
   fMsd         = msd;
   fTDSetOffset = 0;
   fEntryList   = 0;
   fFriends     = 0;
   fValid       = kFALSE;
   fEntries     = -1;

   if (dir)
      fDirectory = dir;

   ResetBit(kWriteV3);
   ResetBit(kHasBeenLookedUp);
   ResetBit(kEmpty);
   ResetBit(kCorrupted);
}

//______________________________________________________________________________
TDSetElement::TDSetElement(const TDSetElement& elem)
             : TNamed(elem.GetFileName(), elem.GetObjName())
{
   // copy constructor
   fDirectory = elem.GetDirectory();
   fFirst = elem.fFirst;
   fNum = elem.fNum;
   fMsd = elem.fMsd;
   fTDSetOffset = elem.fTDSetOffset;
   fEntryList = 0;
   fValid = elem.fValid;
   fEntries = elem.fEntries;
   fFriends = 0;
   ResetBit(kWriteV3);
   ResetBit(kHasBeenLookedUp);
   ResetBit(kEmpty);
   ResetBit(kCorrupted);
}

//______________________________________________________________________________
TDSetElement::~TDSetElement()
{
   // Clean up the element.
   DeleteFriends();
}

//______________________________________________________________________________
TFileInfo *TDSetElement::GetFileInfo(const char *type)
{
   // Return the content of this element in the form of a TFileInfo

   // Create the TFileInfoMeta object
   TFileInfoMeta *meta = 0;
   if (!strcmp(type, "TTree")) {
      meta = new TFileInfoMeta(GetTitle(), "TTree", fEntries, fFirst,
                                fFirst + fEntries - 1);
   } else {
      meta = new TFileInfoMeta(GetTitle(), fDirectory, type, fEntries, fFirst,
                                fFirst + fEntries - 1);
   }
   return new TFileInfo(GetName(), 0, 0, 0, meta);
}

//______________________________________________________________________________
const char *TDSetElement::GetDirectory() const
{
   // Return directory where to look for object.

   return fDirectory;
}

//______________________________________________________________________________
void TDSetElement::Print(Option_t *opt) const
{
   // Print a TDSetElement. When option="a" print full data.

   if (opt && opt[0] == 'a') {
      cout << IsA()->GetName()
           << " file=\"" << GetName()
           << "\" dir=\"" << fDirectory
           << "\" obj=\"" << GetTitle()
           << "\" first=" << fFirst
           << " num=" << fNum
           << " msd=\"" << fMsd
           << "\"" << endl;
   } else
      cout << "\tLFN: " << GetName() << endl;
}

//______________________________________________________________________________
void TDSetElement::Validate(Bool_t isTree)
{
   // Validate by opening the file.

   Long64_t entries = GetEntries(isTree);
   if (entries < 0) return; // Error should be reported by GetEntries()
   if (fFirst < entries) {
      if (fNum == -1) {
         fNum = entries - fFirst;
         fValid = kTRUE;
      } else {
         if (fNum <= entries - fFirst) {
            fValid = kTRUE;
         } else {
            Error("Validate", "TDSetElement has only %d entries starting"
                  " with entry %d, while %d were requested",
                  entries - fFirst, fFirst, fNum);
         }
      }
   } else {
      Error("Validate", "TDSetElement has only %d entries with"
            " first entry requested as %d", entries, fFirst);
   }
}

//______________________________________________________________________________
void TDSetElement::Validate(TDSetElement *elem)
{
   // Validate by checking against another element.

   // NOTE: Since this function validates against another TDSetElement,
   //       if the other TDSetElement (elem) did not use -1 to request all
   //       entries, this TDSetElement may get less than all entries if it
   //       requests all (with -1). For the application it was developed for
   //       (TProofSuperMaster::ValidateDSet) it works, since the design was
   //       to send the elements to their mass storage domain and let them
   //       look at the file and send the info back to the supermaster. The
   //       ability to set fValid was also required to be only exist in
   //       TDSetElement through certain function and not be set externally.
   //       TDSetElement may need to be extended for more general applications.

   if (!elem || !elem->GetValid()) {
      Error("Validate", "TDSetElement to validate against is not valid");
      return;
   }

   TString name = TUrl(GetFileName()).GetFileAndOptions();
   TString elemname = TUrl(elem->GetFileName()).GetFileAndOptions();
   if ((name == elemname) &&
       !strcmp(GetDirectory(), elem->GetDirectory()) &&
       !strcmp(GetObjName(), elem->GetObjName())) {
      Long64_t entries = elem->fFirst + elem->fNum;
      if (fFirst < entries) {
         if (fNum == -1) {
            fNum = entries - fFirst;
            fValid = kTRUE;
         } else {
            if (fNum <= entries - fFirst) {
               fValid = kTRUE;
            } else {
               Error("Validate", "TDSetElement requests %d entries starting"
                     " with entry %d, while TDSetElement to validate against"
                     " has only %d entries", fNum, fFirst, entries);
            }
         }
      } else {
         Error("Validate", "TDSetElement to validate against has only %d"
               " entries, but this TDSetElement requested %d as its first"
               " entry", entries, fFirst);
      }
   } else {
      Error("Validate", "TDSetElements do not refer to same objects");
   }
}

//______________________________________________________________________________
Int_t TDSetElement::Compare(const TObject *obj) const
{
   //Compare elements by filename (and the fFirst).

   if (this == obj) return 0;

   const TDSetElement *elem = dynamic_cast<const TDSetElement*>(obj);
   if (!elem) {
      if (obj)
         return (strncmp(GetName(),obj->GetName(),strlen(GetName()))) ? 1 : 0;
      return -1;
   }

   Int_t order = strncmp(GetName(),elem->GetFileName(),strlen(GetName()));
   if (order == 0) {
      if (GetFirst() < elem->GetFirst())
         return -1;
      else if (GetFirst() > elem->GetFirst())
         return 1;
      return 0;
   }
   return order;
}

//______________________________________________________________________________
void TDSetElement::AddFriend(TDSetElement *friendElement, const char *alias)
{
   // Add friend TDSetElement to this set. The friend element will be copied to this object.

   if (!friendElement) {
      Error("AddFriend", "The friend TDSetElement is null!");
      return;
   }
   if (!fFriends) {
      fFriends = new TList();
      fFriends->SetOwner();
   }
   fFriends->Add(new TPair(new TDSetElement(*friendElement), new TObjString(alias)));
}

//______________________________________________________________________________
void TDSetElement::DeleteFriends()
{
   // Deletes the list of friends and all the friends on the list.
   if (!fFriends)
      return;

   TIter nxf(fFriends);
   TPair *p = 0;
   while ((p = (TPair *) nxf())) {
      delete p->Key();
      delete p->Value();
   }
   delete fFriends;
   fFriends = 0;
}

//______________________________________________________________________________
TDSetElement *TDSet::Next(Long64_t /*totalEntries*/)
{
   // Returns next TDSetElement.

   if (!fIterator) {
      fIterator = new TIter(fElements);
   }

   fCurrent = (TDSetElement *) fIterator->Next();
   return fCurrent;
}

//______________________________________________________________________________
Long64_t TDSetElement::GetEntries(Bool_t isTree, Bool_t openfile)
{
   // Returns number of entries in tree or objects in file.
   // If not yet defined and 'openfile' is TRUE, get the number from the file
   // (may considerably slow down the application).
   // Returns -1 in case of error.

   if (fEntries > -1 || !openfile)
      return fEntries;

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

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

   if (gPerfStats != 0) {
      gPerfStats->FileOpenEvent(file, GetName(), double(TTimeStamp())-start);
   }

   if (file == 0) {
      ::SysError("TDSet::GetEntries", "cannot open file %s", GetName());
      return -1;
   }

   // Record end-point Url and mark as looked-up; be careful to change
   // nothing in the file name, otherwise some cross-checks may fail
   TUrl *eu = (TUrl *) file->GetEndpointUrl();
   eu->SetOptions(TUrl(fname).GetOptions());
   eu->SetAnchor(TUrl(fname).GetAnchor());
   if (strlen(eu->GetProtocol()) > 0 && strcmp(eu->GetProtocol(), "file"))
      fName = eu->GetUrl();
   else
      fName = eu->GetFileAndOptions();
   SetBit(kHasBeenLookedUp);

   TDirectory *dirsave = gDirectory;
   if (!file->cd(fDirectory)) {
      Error("GetEntries", "cannot cd to %s", fDirectory.Data());
      delete file;
      return -1;
   }

   TDirectory *dir = gDirectory;
   dirsave->cd();

   if (isTree) {

      TString on(GetTitle());
      TString sreg(GetTitle());
      // If a wild card we will use the first object of the type
      // requested compatible with the reg expression we got
      if (sreg.Length() <= 0 || sreg == "" || sreg.Contains("*")) {
         if (sreg.Contains("*"))
            sreg.ReplaceAll("*", ".*");
         else
            sreg = ".*";
         TRegexp re(sreg);
         if (dir->GetListOfKeys()) {
            TIter nxk(dir->GetListOfKeys());
            TKey *k = 0;
            Bool_t notfound = kTRUE;
            while ((k = (TKey *) nxk())) {
               if (!strcmp(k->GetClassName(), "TTree")) {
                  TString kn(k->GetName());
                  if (kn.Index(re) != kNPOS) {
                     if (notfound) {
                        on = kn;
                        notfound = kFALSE;
                     } else if (kn != on) {
                       Warning("GetEntries",
                               "additional tree found in the file: %s", kn.Data());
                     }
                  }
               }
            }
         }
      }

      TKey *key = dir->GetKey(on);
      if (key == 0) {
         Error("GetEntries", "cannot find tree \"%s\" in %s",
               GetTitle(), GetName());
         delete file;
         return -1;
      }
      TTree *tree = (TTree *) key->ReadObj();
      if (tree == 0) {
         // Error always reported?
         delete file;
         return -1;
      }
      fEntries = tree->GetEntries();
      delete tree;

   } else {
      TList *keys = dir->GetListOfKeys();
      fEntries = keys->GetSize();
   }

   delete file;
   return fEntries;
}

//______________________________________________________________________________
Int_t TDSetElement::Lookup(Bool_t force)
{
   // Resolve end-point URL for this element
   // Return 0 on success and -1 otherwise
   static Int_t xNetPluginOK = -1;
   static TString xNotRedir;
   static TFileStager *xStager = 0;
   Int_t retVal = 0;

   // Check if required
   if (!force && HasBeenLookedUp())
      return retVal;

   // Open the file as raw to avoid the (slow) initialization
   TUrl url(GetName());
   // Save current options and anchor
   TString anch = url.GetAnchor();
   TString opts = url.GetOptions();
   // The full path
   TString name(url.GetUrl());

   // Depending on the type of backend, it might not make any sense to lookup
   Bool_t doit = kFALSE;
   TFile::EFileType type = TFile::GetType(name, "");
   if (type == TFile::kNet) {
      TPluginHandler *h = 0;
      // Network files via XROOTD
      if (xNetPluginOK == -1) {
         // Check the plugin the first time
         xNetPluginOK = 0;
         if ((h = gROOT->GetPluginManager()->FindHandler("TFile", name)) &&
            !strcmp(h->GetClass(),"TXNetFile") && h->LoadPlugin() == 0)
            xNetPluginOK = 1;
      }
      doit = (xNetPluginOK == 1) ? kTRUE : kFALSE;

      // The server may not be redirector: we might know this from the past
      // experience, if any
      if (xNotRedir.Length() > 0) {
         TUrl u(GetName());
         TString hp(Form("|%s:%d|", u.GetHostFQDN(), u.GetPort()));
         if (xNotRedir.Contains(hp))
            doit = kFALSE;
      }
   }

   // Do it by opening and closing the file. Ideally we could just
   // AccessPathName the path, but the TXNetSystem implementation is very
   // slow. To be fixed.
   if (doit) {
      if (!xStager || !xStager->Matches(name)) {
         SafeDelete(xStager);
         if (!(xStager = TFileStager::Open(name))) {
            Error("Lookup", "TFileStager instance cannot be instantiated");
            retVal = -1;
         }
      }
      if (xStager && xStager->Locate(name.Data(), name) == 0) {
         // Get the effective end-point Url
         url.SetUrl(name);
         // Restore original options and anchor, if any
         url.SetOptions(opts);
         url.SetAnchor(anch);
         // Save it into the element
         fName = url.GetUrl();
      } else {
         // Failure
         Error("Lookup", "couldn't lookup %s\n", name.Data());
         retVal = -1;
      }
   }

   // Mark has looked-up
   SetBit(kHasBeenLookedUp);
   return retVal;
}

//______________________________________________________________________________
void TDSetElement::SetEntryList(TObject *aList, Long64_t first, Long64_t num)
{
   // Set entry (or event) list for this element

   if (!aList)
      return;

   // Link the proper object
   TEventList *evl = 0;
   TEntryList *enl = dynamic_cast<TEntryList*>(aList);
   if (!enl)
      evl = dynamic_cast<TEventList*>(aList);
   if (!enl && !evl) {
      Error("SetEntryList", "type of input object must be either TEntryList "
                            "or TEventList (found: '%s' - do nothing", aList->ClassName());
      return;
   }

   // Action depends on the type
   if (enl) {
      enl->SetEntriesToProcess(num);
   } else {
      for (; num > 0; num--, first++)
         evl->Enter(evl->GetEntry((Int_t)first));
   }
   fEntryList = aList;

   // Done
   return;
}

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

   fElements = new THashList;
   fElements->SetOwner();
   fIsTree    = kFALSE;
   fIterator  = 0;
   fCurrent   = 0;
   fEntryList = 0;
   fProofChain = 0;
   ResetBit(kWriteV3);
   ResetBit(kEmpty);
   ResetBit(kValidityChecked);
   ResetBit(kSomeInvalid);

   // Add to the global list
   gROOT->GetListOfDataSets()->Add(this);
}

//______________________________________________________________________________
TDSet::TDSet(const char *name,
             const char *objname, const char *dir, const char *type)
{
   // Create a named TDSet object. The "type" defines the class of which objects
   // will be processed (default 'TTree'). The optional "objname" argument
   // specifies the name of the objects of the specified class.
   // If the "objname" is not given the behaviour depends on the 'type':
   // for 'TTree' the first TTree is analyzed; for other types, all objects of
   // the class found in the specified directory are processed.
   // The "dir" argument specifies in which directory the objects are
   // to be found, the top level directory ("/") is the default.
   // Directories can be specified using wildcards, e.g. "*" or "/*"
   // means to look in all top level directories, "/dir/*" in all
   // directories under "/dir", and "/*/*" to look in all directories
   // two levels deep.
   // For backward compatibility the type can also be passed via 'name',
   // in which case 'type' is ignored.

   fElements = new THashList;
   fElements->SetOwner();
   fIterator = 0;
   fCurrent  = 0;
   fEntryList = 0;
   fProofChain = 0;
   ResetBit(kWriteV3);
   ResetBit(kEmpty);
   ResetBit(kValidityChecked);
   ResetBit(kSomeInvalid);

   fType = "TTree";
   TClass *c = 0;
   // Check name
   if (name && strlen(name) > 0) {
      // In the old constructor signature it was the 'type'
      if (!type) {
         if ((c = TClass::GetClass(name)))
            fType = name;
         else
            // Default type is 'TTree'
            fName = name;
      } else {
         // Set name
         fName = name;
         // Check type
         if (strlen(type) > 0)
            if ((c = TClass::GetClass(type)))
               fType = type;
      }
   } else if (type && strlen(type) > 0) {
      // Check the type
      if ((c = TClass::GetClass(type)))
         fType = type;
   }
   // The correct class type
   c = TClass::GetClass(fType);

   fIsTree = (c->InheritsFrom("TTree")) ? kTRUE : kFALSE;

   if (objname)
      fObjName = objname;

   if (dir)
      fDir = dir;

   // Default name is the object name
   if (fName.Length() <= 0)
      fName = fObjName;
   // We set the default title to the 'type'
   fTitle = fType;

   // Add to the global list
   gROOT->GetListOfDataSets()->Add(this);
}

//______________________________________________________________________________
TDSet::TDSet(const TChain &chain, Bool_t withfriends)
{
   // Create a named TDSet object from existing TChain 'chain'.
   // If 'withfriends' is kTRUE add also friends.
   // This constructor substituted the static methods TChain::MakeTDSet
   // removing any residual dependence of 'tree' on 'proof'.

   fElements = new THashList;
   fElements->SetOwner();
   fIterator = 0;
   fCurrent  = 0;
   fEntryList = 0;
   fProofChain = 0;
   ResetBit(kWriteV3);
   ResetBit(kEmpty);
   ResetBit(kValidityChecked);
   ResetBit(kSomeInvalid);

   fType = "TTree";
   fIsTree = kTRUE;
   fObjName = chain.GetName();

   // First fill elements without friends()
   TIter next(chain.GetListOfFiles());
   TChainElement *elem;
   while ((elem = (TChainElement *)next())) {
      TString file(elem->GetTitle());
      TString tree(elem->GetName());
      Int_t isl = tree.Index("/");
      TString dir = "/";
      if (isl >= 0) {
         // Copy the tree name specification
         TString behindSlash = tree(isl + 1, tree.Length() - isl - 1);
         // and remove it from basename
         tree.Remove(isl);
         dir = tree;
         tree = behindSlash;
      }
      if (Add(file, tree, dir)) {
         if (elem->HasBeenLookedUp()) {
            // Save lookup information, if any
            TDSetElement *dse = (TDSetElement *) fElements->Last();
            if (dse)
               dse->SetLookedUp();
         }
      }
   }
   SetDirectory(0);

   // Add friends now, if requested
   if (withfriends) {
      TList processed;
      TList chainsQueue;
      chainsQueue.Add((TObject *)&chain);
      processed.Add((TObject *)&chain);
      while (chainsQueue.GetSize() > 0) {
         TChain *c = (TChain *) chainsQueue.First();
         chainsQueue.Remove(c);
         TIter friendsIter(c->GetListOfFriends());
         while(TFriendElement *fe = dynamic_cast<TFriendElement*> (friendsIter()) ) {
            if (TChain *fc = dynamic_cast<TChain*>(fe->GetTree())) {
               if (!processed.FindObject(fc)) {    // if not yet processed
                  processed.AddFirst(fc);
                  AddFriend(new TDSet((const TChain &)(*fc), kFALSE), fe->GetName());
                  chainsQueue.Add(fc);                        // for further processing
               }
            } else {
               Reset();
               Error("TDSet", "Only TChains supported. Found illegal tree %s",
                              fe->GetTree()->GetName());
               return;
            }
         }
      }
   }
}

//______________________________________________________________________________
TDSet::~TDSet()
{
   // Cleanup.

   SafeDelete(fElements);
   SafeDelete(fIterator);
   SafeDelete(fProofChain);

   gROOT->GetListOfDataSets()->Remove(this);
}

//______________________________________________________________________________
Long64_t TDSet::Process(const char *selector, Option_t *option, Long64_t nentries,
                        Long64_t first, TObject *enl)
{
   // Process TDSet on currently active PROOF session.
   // The last argument 'enl' specifies an entry- or event-list to be used as
   // event selection.
   // The return value is -1 in case of error and TSelector::GetStatus() in
   // in case of success.

   if (!IsValid() || !fElements->GetSize()) {
      Error("Process", "not a correctly initialized TDSet");
      return -1;
   }

   // Set entry list
   SetEntryList(enl);

   if (gProof)
      return gProof->Process(this, selector, option, nentries, first);

   Error("Process", "no active PROOF session");
   return -1;
}

//______________________________________________________________________________
void TDSet::AddInput(TObject *obj)
{
   // Add objects that might be needed during the processing of
   // the selector (see Process()).

   if (gProof) {
      gProof->AddInput(obj);
   } else {
      Error("AddInput","No PROOF session active");
   }
}

//______________________________________________________________________________
void TDSet::ClearInput()
{
   // Clear input object list.

   if (gProof)
      gProof->ClearInput();
}

//______________________________________________________________________________
TObject *TDSet::GetOutput(const char *name)
{
   // Get specified object that has been produced during the processing
   // (see Process()).

   if (gProof)
      return gProof->GetOutput(name);
   return 0;
}

//______________________________________________________________________________
TList *TDSet::GetOutputList()
{
   // Get list with all object created during processing (see Process()).

   if (gProof)
      return gProof->GetOutputList();
   return 0;
}

//______________________________________________________________________________
void TDSet::Print(const Option_t *opt) const
{
   // Print TDSet basic or full data. When option="a" print full data.

   cout <<"OBJ: " << IsA()->GetName() << "\ttype " << GetName() << "\t"
        << fObjName << "\tin " << GetTitle()
        << "\telements " << GetListOfElements()->GetSize() << endl;

   if (opt && opt[0] == 'a') {
      TIter next(GetListOfElements());
      TObject *obj;
      while ((obj = next())) {
         obj->Print(opt);
      }
   }
}

//______________________________________________________________________________
void TDSet::SetObjName(const char *objname)
{
   // Set/change object name.

   if (objname)
      fObjName = objname;
}

//______________________________________________________________________________
void TDSet::SetDirectory(const char *dir)
{
   // Set/change directory.

   if (dir)
      fDir = dir;
}

//______________________________________________________________________________
Bool_t TDSet::Add(const char *file, const char *objname, const char *dir,
                  Long64_t first, Long64_t num, const char *msd)
{
   // Add file to list of files to be analyzed. Optionally with the
   // objname and dir arguments the default, TDSet wide, objname and
   // dir can be overridden.

   if (!file || !*file) {
      Error("Add", "file name must be specified");
      return kFALSE;
   }

   TString fn = file;
   if (gProof && gProof->IsLite()) {
      TUrl u(file, kTRUE);
      if (!strcmp(u.GetProtocol(), "file")) {
         gSystem->ExpandPathName(fn);
         if (!gSystem->IsAbsoluteFileName(fn))
            gSystem->PrependPathName(gSystem->WorkingDirectory(), fn);
      }
   }

   // check, if it already exists in the TDSet
   TDSetElement *el = (TDSetElement *) fElements->FindObject(fn);
   if (el) {
      Warning("Add", "duplicate, %40s is already in dataset, ignored", fn.Data());
      return kFALSE;
   }
   if (!objname)
      objname = GetObjName();
   if (!dir)
      dir = GetDirectory();

   fElements->Add(new TDSetElement(fn, objname, dir, first, num, msd));

   return kTRUE;
}

//______________________________________________________________________________
Bool_t TDSet::Add(TDSet *dset)
{
   // Add specified data set to the this set.

   if (!dset)
      return kFALSE;

   if (fType != dset->GetType()) {
      Error("Add", "cannot add a set with a different type");
      return kFALSE;
   }

   TDSetElement *el;
   TIter next(dset->fElements);
   TObject *last = (dset == this) ? fElements->Last() : 0;
   while ((el = (TDSetElement*) next())) {
      Add(el->GetFileName(), el->GetObjName(), el->GetDirectory(),
          el->GetFirst(), el->GetNum(), el->GetMsd());
      if (el == last) break;
   }

   return kTRUE;
}

//______________________________________________________________________________
Bool_t TDSet::Add(TCollection *filelist, const char *meta, Bool_t availableOnly,
                  TCollection *badlist)
{
   // Add files passed as list of TFileInfo, TUrl or TObjString objects .
   // If TFileInfo, the first entry and the number of entries are also filled.
   // The argument 'meta' can be used to specify one of the subsets in the
   // file as described in the metadata of TFileInfo. By default the first one
   // is taken.
   // If 'availableOnly' is true only files available ('staged' and non corrupted)
   // are taken: those not satisfying this requirement are added to 'badlist', if
   // the latter is defined. By default availableOnly is false.

   if (!filelist)
      return kFALSE;

   TObject *o = 0;
   TIter next(filelist);
   while ((o = next())) {
      TString cn(o->ClassName());
      if (cn == "TFileInfo") {
         TFileInfo *fi = (TFileInfo *)o;
         if (!availableOnly ||
            (fi->TestBit(TFileInfo::kStaged) &&
            !fi->TestBit(TFileInfo::kCorrupted))) {
            if (!Add(fi, meta))
               return kFALSE;
         } else if (badlist && fi) {
            // Return list of non-usable files
            badlist->Add(fi);
         }
      } else if (cn == "TUrl") {
         Add(((TUrl *)o)->GetUrl());
      } else if (cn == "TObjString") {
         Add(((TObjString *)o)->GetName());
      } else {
         Warning("Add","found object fo unexpected type %s - ignoring", cn.Data());
      }
   }

   return kTRUE;
}

//______________________________________________________________________________
Bool_t TDSet::Add(TFileInfo *fi, const char *meta)
{
   // Add file described by 'fi' to list of files to be analyzed.
   // The argument 'meta' can be used to specify a subsets in the
   // file as described in the metadata of TFileInfo. By default the first one
   // is taken.

   if (!fi) {
      Error("Add", "TFileInfo object name must be specified");
      return kFALSE;
   }

   // Element to be added
   TDSetElement *el = 0;

   // Check if it already exists in the TDSet
   const char *file = fi->GetFirstUrl()->GetUrl();
   if ((el = (TDSetElement *) fElements->FindObject(file))) {
      Warning("Add", "duplicate, %40s is already in dataset, ignored", file);
      return kFALSE;
   }

   // If more than one metadata info require the specification of the objpath;
   // the order in which they appear is not guaranteed and the error may be
   // very difficult to find.
   TFileInfoMeta *m = 0;
   if (!meta || strlen(meta) <= 0 || !strcmp(meta, "/")) {
      TList *fil = 0;
      if ((fil = fi->GetMetaDataList()) && fil->GetSize() > 1) {
         TString msg = Form("\n  Object name unspecified and several objects available.\n");
         msg += "  Please choose one from the list below:\n";
         TIter nx(fil);
         while ((m = (TFileInfoMeta *) nx())) {
            TString nm(m->GetName());
            if (nm.BeginsWith("/")) nm.Remove(0,1);
            msg += Form("  %s  ->   TProof::Process(\"%s#%s\",...)\n",
                        nm.Data(), GetName(), nm.Data());
         }
         if (gProofServ)
            gProofServ->SendAsynMessage(msg);
         else
            Warning("Add", msg.Data());
         return kFALSE;
      }
   }

   // Get the metadata, if any
   m = fi->GetMetaData(meta);

   // Create the element
   const char *objname = 0;
   const char *dir = 0;
   Long64_t first = 0;
   Long64_t num = -1;
   if (!m) {
      objname = GetObjName();
      dir = GetDirectory();
   } else {
      objname = (m->GetObject() && strlen(m->GetObject())) ? m->GetObject() : GetObjName();
      dir = (m->GetDirectory() && strlen(m->GetDirectory())) ? m->GetDirectory() : GetDirectory();
      first = m->GetFirst();
      num = m->GetEntries();
   }
   el = new TDSetElement(file, objname, dir, first, -1);
   el->SetEntries(num);

   // Set looked-up bit
   if (fi->TestBit(TFileInfo::kStaged))
      el->SetBit(TDSetElement::kHasBeenLookedUp);
   if (fi->TestBit(TFileInfo::kCorrupted))
      el->SetBit(TDSetElement::kCorrupted);

   // Add the element
   fElements->Add(el);

   return kTRUE;
}

//______________________________________________________________________________
Int_t TDSet::ExportFileList(const char *fpath, Option_t *opt)
{
   // Export TDSetElements files as list of TFileInfo objects in file
   // 'fpath'. If the file exists already the action fails, unless
   // 'opt == "F"'.
   // Return 0 on success, -1 otherwise

   if (!fElements)
      return -1;
   if (fElements->GetSize() <= 0)
      return 0;

   Bool_t force = (opt[0] == 'F' || opt[0] == 'f');

   if (gSystem->AccessPathName(fpath, kFileExists) == kFALSE) {
      if (force) {
         // Try removing the file
         if (gSystem->Unlink(fpath)) {
            Info("ExportFileList","error removing dataset file: %s", fpath);
            return -1;
         }
      }
   }

   // Create the file list
   TList *fileinfo = new TList;
   fileinfo->SetOwner();

   TDSetElement *dse = 0;
   TIter next(fElements);
   while ((dse = (TDSetElement *) next())) {
      TFileInfoMeta *m = new TFileInfoMeta(dse->GetTitle(), dse->GetDirectory(), GetType(),
                                           dse->GetNum(), dse->GetFirst());
      TFileInfo *fi = new TFileInfo(dse->GetFileName());
      fi->AddMetaData(m);
      fileinfo->Add(fi);
   }

   // Write to file
   TFile *f = TFile::Open(fpath, "RECREATE");
   if (f) {
      f->cd();
      fileinfo->Write("fileList", TObject::kSingleKey);
      f->Close();
   } else {
      Info("ExportFileList","error creating dataset file: %s", fpath);
      SafeDelete(fileinfo);
      return -1;
   }

   // Cleanup
   SafeDelete(f);
   SafeDelete(fileinfo);

   // We are done
   return 0;
}

//______________________________________________________________________________
void TDSet::AddFriend(TDSet *friendset, const char* alias)
{
   // Add friend dataset to this set. Only possible if the TDSet type is
   // a TTree or derived class. The friendset will be owned by this class
   // and deleted in its destructor.

   if (!friendset) {
      Error("AddFriend", "The friend TDSet is null!");
      return;
   }

   if (!fIsTree) {
      Error("AddFriend", "a friend set can only be added to a TTree TDSet");
      return;
   }
   TList* thisList = GetListOfElements();
   TList* friendsList = friendset->GetListOfElements();
   if (thisList->GetSize() != friendsList->GetSize() && friendsList->GetSize() != 1) {
      Error("AddFriend", "The friend Set has %d elements while the main one has %d",
            thisList->GetSize(), friendsList->GetSize());
      return;
   }
   TIter next(thisList);
   TIter next2(friendsList);
   TDSetElement* friendElem = 0;
   TString aliasString(alias);
   if (friendsList->GetSize() == 1)
      friendElem = dynamic_cast<TDSetElement*> (friendsList->First());
   while(TDSetElement* e = dynamic_cast<TDSetElement*> (next())) {
      if (friendElem) // just one elem in the friend TDSet
         e->AddFriend(friendElem, aliasString);
      else
         e->AddFriend(dynamic_cast<TDSetElement*> (next2()), aliasString);
   }
}

//______________________________________________________________________________
void TDSet::Reset()
{
   // Reset or initialize access to the elements.

   if (!fIterator) {
      fIterator = new TIter(fElements);
   } else {
      fIterator->Reset();
   }
}

//______________________________________________________________________________
Long64_t TDSet::GetEntries(Bool_t isTree, const char *filename, const char *path,
                           TString &objname)
{
   // Returns number of entries in tree or objects in file. Returns -1 in
   // case of error.

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

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

   if (gPerfStats != 0) {
      gPerfStats->FileOpenEvent(file, filename, double(TTimeStamp())-start);
   }

   if (file == 0) {
      ::SysError("TDSet::GetEntries", "cannot open file %s", filename);
      return -1;
   }

   TDirectory *dirsave = gDirectory;
   if (!file->cd(path)) {
      ::Error("TDSet::GetEntries", "cannot cd to %s", path);
      delete file;
      return -1;
   }

   TDirectory *dir = gDirectory;
   dirsave->cd();

   Long64_t entries;
   Bool_t fillname = kFALSE;
   if (isTree) {

      TString on(objname);
      TString sreg(objname);
      // If a wild card we will use the first object of the type
      // requested compatible with the reg expression we got
      if (sreg.Length() <= 0 || sreg == "" || sreg.Contains("*")) {
         fillname = kTRUE;
         if (sreg.Contains("*"))
            sreg.ReplaceAll("*", ".*");
         else
            sreg = ".*";
         TRegexp re(sreg);
         if (dir->GetListOfKeys()) {
            TIter nxk(dir->GetListOfKeys());
            TKey *k = 0;
            Bool_t notfound = kTRUE;
            while ((k = (TKey *) nxk())) {
               if (!strcmp(k->GetClassName(), "TTree")) {
                  TString kn(k->GetName());
                  if (kn.Index(re) != kNPOS) {
                     if (notfound) {
                        on = kn;
                        notfound = kFALSE;
                     } else if (kn != on) {
                       ::Warning("TDSet::GetEntries",
                                 "additional tree found in the file: %s", kn.Data());
                     }
                  }
               }
            }
         }
      }

      TKey *key = dir->GetKey(on);
      if (key == 0) {
         ::Error("TDSet::GetEntries", "cannot find tree \"%s\" in %s",
                 objname.Data(), filename);
         delete file;
         return -1;
      }
      TTree *tree = (TTree *) key->ReadObj();
      if (tree == 0) {
         // Error always reported?
         delete file;
         return -1;
      }
      entries = tree->GetEntries();
      delete tree;

      // Return full name in case of wildcards
      objname = (fillname) ? on : objname;

   } else {
      TList *keys = dir->GetListOfKeys();
      entries = keys->GetSize();
   }

   delete file;
   return entries;
}

//______________________________________________________________________________
Long64_t TDSet::Draw(const char *varexp, const TCut &selection, Option_t *option,
                     Long64_t nentries, Long64_t firstentry)
{
   // Draw expression varexp for specified entries.
   // Returns -1 in case of error or number of selected events in case of success.
   // This function accepts a TCut objects as argument.
   // Use the operator+ to concatenate cuts.
   // Example:
   //   dset.Draw("x",cut1+cut2+cut3);

   return Draw(varexp, selection.GetTitle(), option, nentries, firstentry);
}

//______________________________________________________________________________
Long64_t TDSet::Draw(const char *varexp, const char *selection, Option_t *option,
                     Long64_t nentries, Long64_t firstentry)
{
   // Draw expression varexp for specified entries.
   // Returns -1 in case of error or number of selected events in case of success.
   // For more see TTree::Draw().

   if (!IsValid() || !fElements->GetSize()) {
      Error("Draw", "not a correctly initialized TDSet");
      return -1;
   }

   if (gProof)
      return gProof->DrawSelect(this, varexp, selection, option, nentries,
                                firstentry);

   Error("Draw", "no active PROOF session");
   return -1;
}

//_______________________________________________________________________
void TDSet::StartViewer()
{
   // Start the TTreeViewer on this TTree.

   if (gROOT->IsBatch()) {
      Warning("StartViewer", "viewer cannot run in batch mode");
      return;
   }

   if (!gProof) {
      Error("StartViewer", "no PROOF found");
      return;
   }
   if (!IsTree()) {
      Error("StartViewer", "TDSet contents should be of type TTree (or subtype)");
      return;
   }
   fProofChain = new TProofChain(this, kTRUE);

   TPluginHandler *h;
   if ((h = gROOT->GetPluginManager()->FindHandler("TVirtualTreeViewer"))) {
      if (h->LoadPlugin() == -1)
         return;
      h->ExecPlugin(1,fProofChain);
   }
}

//_______________________________________________________________________
TTree* TDSet::GetTreeHeader(TProof* proof)
{
   // Returns a tree header containing the branches' structure of the dataset.

   return proof->GetTreeHeader(this);
}

//______________________________________________________________________________
Bool_t TDSet::ElementsValid()
{
   // Check if all elements are valid.

   if (TestBit(TDSet::kValidityChecked))
      return (TestBit(TDSet::kSomeInvalid) ? kFALSE : kTRUE);

   SetBit(TDSet::kValidityChecked);
   ResetBit(TDSet::kSomeInvalid);
   TIter nextElem(GetListOfElements());
   while (TDSetElement *elem = dynamic_cast<TDSetElement*>(nextElem())) {
      if (!elem->GetValid()) {
         SetBit(TDSet::kSomeInvalid);
         return kFALSE;
      }
   }
   return kTRUE;
}

//______________________________________________________________________________
Int_t TDSet::Remove(TDSetElement *elem, Bool_t deleteElem)
{
   // Remove TDSetElement 'elem' from the list.
   // Return 0 on success, -1 if the element is not in the list

   if (!elem || !(((THashList *)(GetListOfElements()))->Remove(elem)))
      return -1;

   if (deleteElem)
      SafeDelete(elem);
   return 0;
}

//______________________________________________________________________________
void TDSet::Validate()
{
   // Validate the TDSet by opening files.

   TIter nextElem(GetListOfElements());
   while (TDSetElement *elem = dynamic_cast<TDSetElement*>(nextElem())) {
      if (!elem->GetValid())
         elem->Validate(IsTree());
   }
}

//______________________________________________________________________________
void TDSet::Lookup(Bool_t removeMissing, TList **listOfMissingFiles)
{
   // Resolve the end-point URL for the current elements of this data set
   // If the removeMissing option is set to kTRUE, remove the TDSetElements
   // that can not be located.
   // The method returns the list of removed TDSetElements in *listOfMissingFiles
   // if the latter is defined (the list must be created outside).

   // If an entry- or event- list has been given, assign the relevant portions
   // to each element; this allows to look-up only for the elements which have
   // something to be processed, so it is better to do it before the real look-up
   // operations.
   SplitEntryList();

   TString msg("Looking up for exact location of files");
   UInt_t n = 0;
   UInt_t ng = 0;
   UInt_t tot = GetListOfElements()->GetSize();
   UInt_t n2 = (tot > 50) ? (UInt_t) tot / 50 : 1;
   Bool_t st = kTRUE;
   TIter nextElem(GetListOfElements());
   while (TDSetElement *elem = dynamic_cast<TDSetElement*>(nextElem())) {
      if (elem->GetNum() != 0) { // -1 means "all entries"
         ng++;
         if (!elem->GetValid())
            if (elem->Lookup(kFALSE))
               if (removeMissing) {
                  if (Remove(elem, kFALSE))
                     Error("Lookup", "Error removing a missing file");
                  if (listOfMissingFiles)
                   (*listOfMissingFiles)->Add(elem->GetFileInfo(fType));
               }
      }
      n++;
      // Notify the client
      if (gProof && (n > 0 && !(n % n2)))
         gProof->SendDataSetStatus(msg, n, tot, st);
      // Break if we have been asked to stop
      if (gProof && gProof->GetRunStatus() != TProof::kRunning)
         break;
   }
   // Notify the client if not all the files have entries to be processed
   // (which may happen if an entry-list is used)
   if (ng < tot && gProofServ) {
      msg = Form("Files with entries to be processed: %d (out of %d)\n", ng, tot);
      gProofServ->SendAsynMessage(msg);
   } else {
      // Final notification to the client
      if (gProof) gProof->SendDataSetStatus(msg, n, tot, st);
   }
   // Done
   return;
}

//______________________________________________________________________________
void TDSet::SetLookedUp()
{
   // Flag all the elements as looked-up, so to avoid opening the files
   // if the functionality is not supported

   TIter nextElem(GetListOfElements());
   while (TDSetElement *elem = dynamic_cast<TDSetElement*>(nextElem()))
      elem->SetLookedUp();
}

//______________________________________________________________________________
void TDSet::Validate(TDSet* dset)
{
   // Validate the TDSet against another TDSet.
   // Only validates elements in common from input TDSet.

   THashList bestElements;
   bestElements.SetOwner();
   TList namedHolder;
   namedHolder.SetOwner();
   TIter nextOtherElem(dset->GetListOfElements());
   while (TDSetElement *elem = dynamic_cast<TDSetElement*>(nextOtherElem())) {
      if (!elem->GetValid()) continue;
      TString dir_file_obj = elem->GetDirectory();
      dir_file_obj += "_";
      dir_file_obj += TUrl(elem->GetFileName()).GetFileAndOptions();
      dir_file_obj += "_";
      dir_file_obj += elem->GetObjName();
      TPair *p = dynamic_cast<TPair*>(bestElements.FindObject(dir_file_obj));
      if (p) {
         TDSetElement *prevelem = dynamic_cast<TDSetElement*>(p->Value());
         Long64_t entries = prevelem->GetFirst()+prevelem->GetNum();
         if (entries<elem->GetFirst()+elem->GetNum()) {
            bestElements.Remove(p);
            bestElements.Add(new TPair(p->Key(), elem));
            delete p;
         }
      } else {
         TNamed* named = new TNamed(dir_file_obj, dir_file_obj);
         namedHolder.Add(named);
         bestElements.Add(new TPair(named, elem));
      }
   }

   TIter nextElem(GetListOfElements());
   while (TDSetElement *elem = dynamic_cast<TDSetElement*>(nextElem())) {
      if (!elem->GetValid()) {
         TString dir_file_obj = elem->GetDirectory();
         dir_file_obj += "_";
         dir_file_obj += TUrl(elem->GetFileName()).GetFileAndOptions();
         dir_file_obj += "_";
         dir_file_obj += elem->GetObjName();
         if (TPair *p = dynamic_cast<TPair*>(bestElements.FindObject(dir_file_obj))) {
            TDSetElement* validelem = dynamic_cast<TDSetElement*>(p->Value());
            elem->Validate(validelem);
         }
      }
   }
}

//
// To handle requests coming from version 3 client / masters we need
// a special streamer
//______________________________________________________________________________
void TDSetElement::Streamer(TBuffer &R__b)
{
   // Stream an object of class TDSetElement.

   if (R__b.IsReading()) {
      UInt_t R__s, R__c;
      Version_t R__v = R__b.ReadVersion(&R__s, &R__c);
      ResetBit(kWriteV3);
      if (R__v > 4) {
         R__b.ReadClassBuffer(TDSetElement::Class(), this, R__v, R__s, R__c);
      } else {
         // For version 3 client / masters we need a special streamer
         SetBit(kWriteV3);
         if (R__v > 3) {
            TNamed::Streamer(R__b);
         } else {
            // Old versions were not deriving from TNamed and had the
            // file name and the object type name in the first two members
            TObject::Streamer(R__b);
            TString name, title;
            R__b >> name >> title;
            SetNameTitle(name, title);
         }
         // Now we read the standard part
         R__b >> fDirectory;
         R__b >> fFirst;
         R__b >> fNum;
         R__b >> fMsd;
         R__b >> fTDSetOffset;
         TEventList *evl;
         R__b >> evl;
         R__b >> fValid;
         R__b >> fEntries;

         // Special treatment waiting for proper retrieving of stl containers
         FriendsList_t *friends = new FriendsList_t;
         static TClassRef classFriendsList = TClass::GetClass(typeid(FriendsList_t));
         R__b.ReadClassBuffer( classFriendsList, friends, classFriendsList->GetClassVersion(), 0, 0);
         if (friends) {
            // Convert friends to a TList (to be written)
            fFriends = new TList();
            fFriends->SetOwner();
            for (FriendsList_t::iterator i = friends->begin();
                 i != friends->end(); ++i) {
               TDSetElement *dse = (TDSetElement *) i->first->Clone();
               fFriends->Add(new TPair(dse, new TObjString(i->second.Data())));
            }
         }
         // the value for fIsTree (only older versions are sending it)
         Bool_t tmpIsTree;
         R__b >> tmpIsTree;
         R__b.CheckByteCount(R__s, R__c, TDSetElement::IsA());
      }
   } else {
      if (TestBit(kWriteV3)) {
         // For version 3 client / masters we need a special streamer
         R__b << Version_t(3);
         TObject::Streamer(R__b);
         R__b << TString(GetName());
         R__b << TString(GetTitle());
         R__b << fDirectory;
         R__b << fFirst;
         R__b << fNum;
         R__b << fMsd;
         R__b << fTDSetOffset;
         R__b << (TEventList *)0;
         R__b << fValid;
         R__b << fEntries;

         // Special treatment waiting for proper retrieving of stl containers
         FriendsList_t *friends = new FriendsList_t;
         if (fFriends) {
            TIter nxf(fFriends);
            TPair *p = 0;
            while ((p = (TPair *)nxf()))
               friends->push_back(std::make_pair((TDSetElement *)p->Key(),
                                   TString(((TObjString *)p->Value())->GetName())));
         }
         static TClassRef classFriendsList = TClass::GetClass(typeid(FriendsList_t));
         R__b.WriteClassBuffer( classFriendsList, &friends );

         // Older versions had an unused boolean called fIsTree: we fill it
         // with its default value
         R__b << kFALSE;
      } else {
         R__b.WriteClassBuffer(TDSetElement::Class(),this);
      }
   }
}

//______________________________________________________________________________
void TDSet::Streamer(TBuffer &R__b)
{
   // Stream an object of class TDSet.

   if (R__b.IsReading()) {
      UInt_t R__s, R__c;
      Version_t R__v = R__b.ReadVersion(&R__s, &R__c);
      ResetBit(kWriteV3);
      if (R__v > 3) {
         R__b.ReadClassBuffer(TDSet::Class(), this, R__v, R__s, R__c);
      } else {
         // For version 3 client / masters we need a special streamer
         SetBit(kWriteV3);
         TNamed::Streamer(R__b);
         R__b >> fDir;
         R__b >> fType;
         R__b >> fObjName;
         TList elems;
         elems.Streamer(R__b);
         elems.SetOwner(kFALSE);
         if (elems.GetSize() > 0) {
            fElements = new THashList;
            fElements->SetOwner();
            TDSetElement *e = 0;
            TIter nxe(&elems);
            while ((e = (TDSetElement *)nxe())) {
               fElements->Add(e);
            }
         } else {
            fElements = 0;
         }
         R__b >> fIsTree;
      }
   } else {
      if (TestBit(kWriteV3)) {
         // For version 3 client / masters we need a special streamer
         R__b << Version_t(3);
         TNamed::Streamer(R__b);
         R__b << fDir;
         R__b << fType;
         R__b << fObjName;
         TList elems;
         if (fElements) {
            elems.SetOwner(kFALSE);
            if (fElements->GetSize() > 0) {
               TDSetElement *e = 0;
               TIter nxe(fElements);
               while ((e = (TDSetElement *)nxe()))
                  elems.Add(e);
            }
         }
         elems.Streamer(R__b);
         R__b << fIsTree;
      } else {
         R__b.WriteClassBuffer(TDSet::Class(),this);
      }
   }
}

//______________________________________________________________________________
void TDSet::SetWriteV3(Bool_t on)
{
   // Set/Reset the 'OldStreamer' bit in this instance and its elements.
   // Needed for backward compatibility in talking to old client / masters.

   if (on)
      SetBit(TDSet::kWriteV3);
   else
      ResetBit(TDSet::kWriteV3);
   // Loop over dataset elements
   TIter nxe(GetListOfElements());
   TObject *o = 0;
   while ((o = nxe()))
      if (on)
         o->SetBit(TDSetElement::kWriteV3);
      else
         o->ResetBit(TDSetElement::kWriteV3);
}

//______________________________________________________________________________
void TDSet::SetEntryList(TObject *aList)
{
   // Set entry (or event) list for this data set

   if (!aList)
      return;

   // Link the proper object
   TEventList *evl = 0;
   TEntryList *enl = dynamic_cast<TEntryList*>(aList);
   if (!enl)
      evl = dynamic_cast<TEventList*>(aList);
   if (!enl && !evl) {
      Error("SetEntryList", "type of input object must be either TEntryList "
                            "or TEventList (found: '%s' - do nothing", aList->ClassName());
      return;
   }

   // Action depends on the type
   fEntryList = (enl) ? enl : (TEntryList *)evl;

   // Done
   return;
}

//______________________________________________________________________________
void TDSet::SplitEntryList()
{
   // Splits the main entry (or event) list into sub-lists for the elements of
   // thet data set

   if (!fEntryList) {
      if (gDebug > 0)
         Info("SplitEntryList", "no entry- (or event-) list to split - do nothing");
      return;
   }

   // Action depend on type of list
   TEntryList *enl = dynamic_cast<TEntryList *>(fEntryList);
   if (enl) {
      // TEntryList
      TIter next(fElements);
      TDSetElement *el=0;
      TEntryList *sublist = 0;
      while ((el=(TDSetElement*)next())){
         sublist = enl->GetEntryList(el->GetObjName(), el->GetFileName());
         if (sublist){
            el->SetEntryList(sublist);
            el->SetNum(sublist->GetN());
         } else {
            sublist = new TEntryList("", "");
            el->SetEntryList(sublist);
            el->SetNum(0);
         }
      }
   } else {
      TEventList *evl = dynamic_cast<TEventList *>(fEntryList);
      if (evl) {
         // TEventList
         TIter next(fElements);
         TDSetElement *el, *prev;

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