ROOT logo
// @(#)root/base:$Id: TROOT.cxx 41514 2011-10-20 14:34:33Z rdm $
// Author: Rene Brun   08/12/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.             *
 *************************************************************************/

////////////////////////////////////////////////////////////////////////////////
//                R O O T top level object description
//
//    The TROOT object is the entry point to the ROOT system.
//    The single instance of TROOT is accessible via the global gROOT.
//    Using the gROOT pointer one has access to basically every object
//    created in a ROOT based program. The TROOT object is essentially a
//    container of several lists pointing to the main ROOT objects.
//
//    The following lists are accessible from gROOT object:
//       gROOT->GetListOfClasses
//       gROOT->GetListOfColors
//       gROOT->GetListOfTypes
//       gROOT->GetListOfGlobals
//       gROOT->GetListOfGlobalFunctions
//       gROOT->GetListOfFiles
//       gROOT->GetListOfMappedFiles
//       gROOT->GetListOfSockets
//       gROOT->GetListOfSecContexts
//       gROOT->GetListOfCanvases
//       gROOT->GetListOfStyles
//       gROOT->GetListOfFunctions
//       gROOT->GetListOfSpecials (for example graphical cuts)
//       gROOT->GetListOfGeometries
//       gROOT->GetListOfBrowsers
//       gROOT->GetListOfCleanups
//       gROOT->GetListOfMessageHandlers
//
//   The TROOT class provides also many useful services:
//     - Get pointer to an object in any of the lists above
//     - Time utilities TROOT::Time
//
//   The ROOT object must be created as a static object. An example
//   of a main program creating an interactive version is shown below:
//
//---------------------Example of a main program--------------------------------
//
//       #include "TRint.h"
//
//       int main(int argc, char **argv)
//       {
//          TRint *theApp = new TRint("ROOT example", &argc, argv);
//
//          // Init Intrinsics, build all windows, and enter event loop
//          theApp->Run();
//
//          return(0);
//       }
//-----------------------End of Main program--------------------------------
////////////////////////////////////////////////////////////////////////////////

#include "RConfig.h"
#include "RConfigure.h"
#include "RConfigOptions.h"

#include <string>
#include <map>
#include <stdlib.h>
#ifdef WIN32
#include <io.h>
#endif

#include "Riostream.h"
#include "Gtypes.h"
#include "TROOT.h"
#include "TClass.h"
#include "TClassEdit.h"
#include "TClassGenerator.h"
#include "TDataType.h"
#include "TDatime.h"
#include "TStyle.h"
#include "TObjectTable.h"
#include "TClassTable.h"
#include "TSystem.h"
#include "THashList.h"
#include "TObjArray.h"
#include "TEnv.h"
#include "TError.h"
#include "TColor.h"
#include "TGlobal.h"
#include "TFunction.h"
#include "TVirtualPad.h"
#include "TBrowser.h"
#include "TSystemDirectory.h"
#include "TApplication.h"
#include "TInterpreter.h"
#include "TGuiFactory.h"
#include "TMessageHandler.h"
#include "TFolder.h"
#include "TQObject.h"
#include "TProcessUUID.h"
#include "TPluginManager.h"
#include "TMap.h"
#include "TObjString.h"
#include "TVirtualMutex.h"
#ifdef R__HAS_CLING
# include "TCintWithCling.h"
#else
# include "TCint.h"
#endif

#include <string>
namespace std {} using namespace std;

#if defined(R__UNIX)
#include "TUnixSystem.h"
#elif defined(R__WIN32)
#include "TWinNTSystem.h"
#endif

extern "C" void R__SetZipMode(int);

// Mutex for protection of concurrent gROOT access
TVirtualMutex* gROOTMutex = 0;

// For accesing TThread::Tsd indirectly.
void **(*gThreadTsd)(void*,Int_t) = 0;

//-------- Names of next three routines are a small homage to CMZ --------------
//______________________________________________________________________________
static Int_t IVERSQ()
{
   // Return version id as an integer, i.e. "2.22/04" -> 22204.

   Int_t maj, min, cycle;
   sscanf(ROOT_RELEASE, "%d.%d/%d", &maj, &min, &cycle);
   return 10000*maj + 100*min + cycle;
}

//______________________________________________________________________________
static Int_t IDATQQ(const char *date)
{
   // Return built date as integer, i.e. "Apr 28 2000" -> 20000428.

   static const char *months[] = {"Jan","Feb","Mar","Apr","May",
                                  "Jun","Jul","Aug","Sep","Oct",
                                  "Nov","Dec"};

   char  sm[12];
   Int_t yy, mm=0, dd;
   sscanf(date, "%s %d %d", sm, &dd, &yy);
   for (int i = 0; i < 12; i++)
      if (!strncmp(sm, months[i], 3)) {
         mm = i+1;
         break;
      }
   return 10000*yy + 100*mm + dd;
}

//______________________________________________________________________________
static Int_t ITIMQQ(const char *time)
{
   // Return built time as integer (with min precision), i.e.
   // "17:32:37" -> 1732.

   Int_t hh, mm, ss;
   sscanf(time, "%d:%d:%d", &hh, &mm, &ss);
   return 100*hh + mm;
}
//______________________________________________________________________________
static void CleanUpROOTAtExit()
{
   // Clean up at program termination before global objects go out of scope.

   if (gROOT) {
      R__LOCKGUARD(gROOTMutex);

      if (gROOT->GetListOfFiles())
         gROOT->GetListOfFiles()->Delete("slow");
      if (gROOT->GetListOfSockets())
         gROOT->GetListOfSockets()->Delete();
      if (gROOT->GetListOfMappedFiles())
         gROOT->GetListOfMappedFiles()->Delete("slow");
      if (gROOT->GetListOfClosedObjects())
         gROOT->GetListOfClosedObjects()->Delete("slow");
   }
}



Int_t  TROOT::fgDirLevel = 0;
Bool_t TROOT::fgRootInit = kFALSE;
Bool_t TROOT::fgMemCheck = kFALSE;

// This local static object initializes the ROOT system
namespace ROOT {
   TROOT *GetROOT() {
      static TROOT root("root", "The ROOT of EVERYTHING");
      return &root;
   }
   TString &GetMacroPath() {
      static TString macroPath;
      return macroPath;
   }
}

TROOT *gROOT = ROOT::GetROOT();     // The ROOT of EVERYTHING

// Global debug flag (set to > 0 to get debug output).
// Can be set either via the interpreter (gDebug is exported to CINT),
// via the rootrc resouce "Root.Debug", via the shell environment variable
// ROOTDEBUG, or via the debugger.
Int_t gDebug;


ClassImp(TROOT)

//______________________________________________________________________________
TROOT::TROOT() : TDirectory(),
     fLineIsProcessing(0), fVersion(0), fVersionInt(0), fVersionCode(0),
     fVersionDate(0), fVersionTime(0), fBuiltDate(0), fBuiltTime(0), fSvnRevision(0),
     fTimer(0), fApplication(0), fInterpreter(0), fBatch(kTRUE), fEditHistograms(kTRUE),
     fFromPopUp(kTRUE),fMustClean(kTRUE),fReadingObject(kFALSE),fForceStyle(kFALSE),
     fInterrupt(kFALSE),fEscape(kFALSE),fExecutingMacro(kFALSE),fEditorMode(0),
     fPrimitive(0),fSelectPad(0),fClasses(0),fTypes(0),fGlobals(0),fGlobalFunctions(0),
     fClosedObjects(0),fFiles(0),fMappedFiles(0),fSockets(0),fCanvases(0),fStyles(0),fFunctions(0),
     fTasks(0),fColors(0),fGeometries(0),fBrowsers(0),fSpecials(0),fCleanups(0),
     fMessageHandlers(0),fStreamerInfo(0),fClassGenerators(0),fSecContexts(0),
     fProofs(0),fClipboard(0),fDataSets(0),fUUIDs(0),fRootFolder(0),fBrowsables(0),
     fPluginManager(0)
{
   // Default ctor.
}

//______________________________________________________________________________
TROOT::TROOT(const char *name, const char *title, VoidFuncPtr_t *initfunc)
   : TDirectory(), fLineIsProcessing(0), fVersion(0), fVersionInt(0), fVersionCode(0),
     fVersionDate(0), fVersionTime(0), fBuiltDate(0), fBuiltTime(0), fSvnRevision(0),
     fTimer(0), fApplication(0), fInterpreter(0), fBatch(kTRUE), fEditHistograms(kTRUE),
     fFromPopUp(kTRUE),fMustClean(kTRUE),fReadingObject(kFALSE),fForceStyle(kFALSE),
     fInterrupt(kFALSE),fEscape(kFALSE),fExecutingMacro(kFALSE),fEditorMode(0),
     fPrimitive(0),fSelectPad(0),fClasses(0),fTypes(0),fGlobals(0),fGlobalFunctions(0),
     fClosedObjects(0),fFiles(0),fMappedFiles(0),fSockets(0),fCanvases(0),fStyles(0),fFunctions(0),
     fTasks(0),fColors(0),fGeometries(0),fBrowsers(0),fSpecials(0),fCleanups(0),
     fMessageHandlers(0),fStreamerInfo(0),fClassGenerators(0),fSecContexts(0),
     fProofs(0),fClipboard(0),fDataSets(0),fUUIDs(0),fRootFolder(0),fBrowsables(0),
     fPluginManager(0)
{
   // Initialize the ROOT system. The creation of the TROOT object initializes
   // the ROOT system. It must be the first ROOT related action that is
   // performed by a program. The TROOT object must be created on the stack
   // (can not be called via new since "operator new" is protected). The
   // TROOT object is either created as a global object (outside the main()
   // program), or it is one of the first objects created in main().
   // Make sure that the TROOT object stays in scope for as long as ROOT
   // related actions are performed. TROOT is a so called singleton so
   // only one instance of it can be created. The single TROOT object can
   // always be accessed via the global pointer gROOT.
   // The name and title arguments can be used to identify the running
   // application. The initfunc argument can contain an array of
   // function pointers (last element must be 0). These functions are
   // executed at the end of the constructor. This way one can easily
   // extend the ROOT system without adding permanent dependencies
   // (e.g. the graphics system is initialized via such a function).

   if (fgRootInit) {
      //Warning("TROOT", "only one instance of TROOT allowed");
      return;
   }

   R__LOCKGUARD2(gROOTMutex);

   gROOT      = this;
   gDirectory = 0;
   SetName(name);
   SetTitle(title);
   TDirectory::Build();

   // will be used by global "operator delete" so make sure it is set
   // before anything is deleted
   fMappedFiles = 0;

   // create already here, but only initialize it after gEnv has been created
   gPluginMgr = fPluginManager = new TPluginManager;

   // Initialize Operating System interface
   InitSystem();

#ifndef ROOTPREFIX
   if (!gSystem->Getenv("ROOTSYS")) {
      fprintf(stderr, "Fatal in <TROOT::TROOT>: ROOTSYS not set. Set it before trying to run.\n");
      exit(1);
   }
#endif

   // Initialize interface to CINT C++ interpreter
   fVersionInt      = 0;  // check in TROOT dtor in case TCint fails
   fClasses         = 0;  // might be checked via TCint ctor

#ifdef R__HAS_CLING
   fInterpreter     = new TCintWithCling("C/C++", "CINT+cling C/C++ Interpreter");
#else
   fInterpreter     = new TCint("C/C++", "CINT C/C++ Interpreter");
#endif
   fConfigOptions   = R__CONFIGUREOPTIONS;
   fConfigFeatures  = R__CONFIGUREFEATURES;
   fVersion         = ROOT_RELEASE;
   fVersionCode     = ROOT_VERSION_CODE;
   fVersionInt      = IVERSQ();
   fVersionDate     = IDATQQ(ROOT_RELEASE_DATE);
   fVersionTime     = ITIMQQ(ROOT_RELEASE_TIME);
   fBuiltDate       = IDATQQ(__DATE__);
   fBuiltTime       = ITIMQQ(__TIME__);

   ReadSvnInfo();

   fClasses         = new THashTable(800,3);
   //fIdMap           = new IdMap_t;
   fStreamerInfo    = new TObjArray(100);
   fClassGenerators = new TList;

   // initialize plugin manager early
   fPluginManager->LoadHandlersFromEnv(gEnv);
#if defined(R__MACOSX) && (TARGET_OS_IPHONE || TARGET_IPHONE_SIMULATOR)
   if (TARGET_OS_IPHONE | TARGET_IPHONE_SIMULATOR) {
      TEnv plugins(".plugins-ios");
      fPluginManager->LoadHandlersFromEnv(&plugins);
   }
#endif

   TSystemDirectory *workdir = new TSystemDirectory("workdir", gSystem->WorkingDirectory());

   fTimer       = 0;
   fApplication = 0;
   fColors      = new TObjArray(1000); fColors->SetName("ListOfColors");
   fTypes       = 0;
   fGlobals     = 0;
   fGlobalFunctions = 0;
   // fList was created in TDirectory::Build but with different sizing.
   delete fList;
   fList        = new THashList(1000,3);
   fClosedObjects = new TList; fClosedObjects->SetName("ClosedFiles");
   fFiles       = new TList; fFiles->SetName("Files");
   fMappedFiles = new TList; fMappedFiles->SetName("MappedFiles");
   fSockets     = new TList; fSockets->SetName("Sockets");
   fCanvases    = new TList; fCanvases->SetName("Canvases");
   fStyles      = new TList; fStyles->SetName("Styles");
   fFunctions   = new TList; fFunctions->SetName("Functions");
   fTasks       = new TList; fTasks->SetName("Tasks");
   fGeometries  = new TList; fGeometries->SetName("Geometries");
   fBrowsers    = new TList; fBrowsers->SetName("Browsers");
   fSpecials    = new TList; fSpecials->SetName("Specials");
   fBrowsables  = new TList; fBrowsables->SetName("Browsables");
   fCleanups    = new THashList; fCleanups->SetName("Cleanups");
   fMessageHandlers = new TList; fMessageHandlers->SetName("MessageHandlers");
   fSecContexts = new TList; fSecContexts->SetName("SecContexts");
   fProofs      = new TList; fProofs->SetName("Proofs");
   fClipboard   = new TList; fClipboard->SetName("Clipboard");
   fDataSets    = new TList; fDataSets->SetName("DataSets");

   TProcessID::AddProcessID();
   fUUIDs = new TProcessUUID();

   fRootFolder = new TFolder();
   fRootFolder->SetName("root");
   fRootFolder->SetTitle("root of all folders");
   fRootFolder->AddFolder("Classes",   "List of Active Classes",fClasses);
   fRootFolder->AddFolder("Colors",    "List of Active Colors",fColors);
   fRootFolder->AddFolder("MapFiles",  "List of MapFiles",fMappedFiles);
   fRootFolder->AddFolder("Sockets",   "List of Socket Connections",fSockets);
   fRootFolder->AddFolder("Canvases",  "List of Canvases",fCanvases);
   fRootFolder->AddFolder("Styles",    "List of Styles",fStyles);
   fRootFolder->AddFolder("Functions", "List of Functions",fFunctions);
   fRootFolder->AddFolder("Tasks",     "List of Tasks",fTasks);
   fRootFolder->AddFolder("Geometries","List of Geometries",fGeometries);
   fRootFolder->AddFolder("Browsers",  "List of Browsers",fBrowsers);
   fRootFolder->AddFolder("Specials",  "List of Special Objects",fSpecials);
   fRootFolder->AddFolder("Handlers",  "List of Message Handlers",fMessageHandlers);
   fRootFolder->AddFolder("Cleanups",  "List of RecursiveRemove Collections",fCleanups);
   fRootFolder->AddFolder("StreamerInfo","List of Active StreamerInfo Classes",fStreamerInfo);
   fRootFolder->AddFolder("SecContexts","List of Security Contexts",fSecContexts);
   fRootFolder->AddFolder("PROOF Sessions", "List of PROOF sessions",fProofs);
   fRootFolder->AddFolder("ROOT Memory","List of Objects in the gROOT Directory",fList);
   fRootFolder->AddFolder("ROOT Files","List of Connected ROOT Files",fFiles);

   // by default, add the list of files, tasks, canvases and browsers in the Cleanups list
   fCleanups->Add(fCanvases); fCanvases->SetBit(kMustCleanup);
   fCleanups->Add(fBrowsers); fBrowsers->SetBit(kMustCleanup);
   fCleanups->Add(fTasks);    fTasks->SetBit(kMustCleanup);
   fCleanups->Add(fFiles);    fFiles->SetBit(kMustCleanup);
   fCleanups->Add(fClosedObjects); fClosedObjects->SetBit(kMustCleanup);
   fCleanups->Add(fInterpreter);   fInterpreter->SetBit(kMustCleanup);

   fExecutingMacro= kFALSE;
   fForceStyle    = kFALSE;
   fFromPopUp     = kFALSE;
   fReadingObject = kFALSE;
   fInterrupt     = kFALSE;
   fEscape        = kFALSE;
   fMustClean     = kTRUE;
   fPrimitive     = 0;
   fSelectPad     = 0;
   fEditorMode    = 0;
   fDefCanvasName = "c1";
   fEditHistograms= kFALSE;
   fLineIsProcessing = 1;   // This prevents WIN32 "Windows" thread to pick ROOT objects with mouse
   gDirectory     = this;
   gPad           = 0;

   //set name of graphical cut class for the graphics editor
   //cannot call SetCutClassName at this point because the TClass of TCutG
   //is not yet build
   fCutClassName = "TCutG";

   // Create a default MessageHandler
   new TMessageHandler((TClass*)0);

   // Create some styles
   gStyle = 0;
   TStyle::BuildStyles();
   SetStyle(gEnv->GetValue("Canvas.Style", "Modern"));

   // Setup default (batch) graphics and GUI environment
   gBatchGuiFactory = new TGuiFactory;
   gGuiFactory      = gBatchGuiFactory;
   gGXBatch         = new TVirtualX("Batch", "ROOT Interface to batch graphics");
   gVirtualX        = gGXBatch;

#ifdef R__WIN32
   fBatch = kFALSE;
#else
   if (gSystem->Getenv("DISPLAY"))
      fBatch = kFALSE;
   else
      fBatch = kTRUE;
#endif

   int i = 0;
   while (initfunc && initfunc[i]) {
      (initfunc[i])();
      fBatch = kFALSE;  // put system in graphics mode (backward compatible)
      i++;
   }

   // Load and init threads library
   InitThreads();

   // Load RQ_OBJECT.h in interpreter (allows signal/slot programming, like Qt)
   TQObject::LoadRQ_OBJECT();

   // Set initial/default list of browsable objects
   fBrowsables->Add(fRootFolder, "root");
   fBrowsables->Add(fProofs, "PROOF Sessions");
   fBrowsables->Add(workdir, gSystem->WorkingDirectory());
   fBrowsables->Add(fFiles, "ROOT Files");

   atexit(CleanUpROOTAtExit);

   fgRootInit = kTRUE;

   TClass::ReadRules(); // Read the default customization rules ...
}

//______________________________________________________________________________
TROOT::~TROOT()
{
   // Clean up and free resources used by ROOT (files, network sockets,
   // shared memory segments, etc.).

   if (gROOT == this) {

      // Mark the object as invalid, so that we can veto some actions
      // (like autoloading) while we are in the destructor.
      SetBit(TObject::kInvalidObject);

      // Turn-off the global mutex to avoid recreating mutexes that have
      // already been deleted during the destruction phase
      gGlobalMutex = 0;

      // Return when error occured in TCint, i.e. when setup file(s) are
      // out of date
      if (!fVersionInt) return;

      // ATTENTION!!! Order is important!

#ifdef R__COMPLETE_MEM_TERMINATION
      SafeDelete(fBrowsables);
      SafeDelete(fRootFolder);
      fSpecials->Delete();   SafeDelete(fSpecials);    // delete special objects : PostScript, Minuit, Html
#endif
      fClosedObjects->Delete("slow"); // and closed files
      fFiles->Delete("slow");       // and files
      SafeDelete(fFiles);
      fSecContexts->Delete("slow"); SafeDelete(fSecContexts); // and security contexts
      fSockets->Delete();           SafeDelete(fSockets);     // and sockets
      fMappedFiles->Delete("slow");                     // and mapped files
      delete fUUIDs;
      TProcessID::Cleanup();                            // and list of ProcessIDs
      TSeqCollection *tl = fMappedFiles; fMappedFiles = 0; delete tl;

      SafeDelete(fClosedObjects);

      fFunctions->Delete();  SafeDelete(fFunctions);   // etc..
      fColors->Delete();     SafeDelete(fColors);
      fStyles->Delete();     SafeDelete(fStyles);
      fGeometries->Delete(); SafeDelete(fGeometries);
      fBrowsers->Delete();   SafeDelete(fBrowsers);

#ifdef R__COMPLETE_MEM_TERMINATION
      if (gGuiFactory != gBatchGuiFactory) SafeDelete(gGuiFactory);
      SafeDelete(gBatchGuiFactory);
      if (gGXBatch != gVirtualX) SafeDelete(gGXBatch);
      SafeDelete(gVirtualX);
#endif

      // Stop emitting signals
      TQObject::BlockAllSignals(kTRUE);

      fMessageHandlers->Delete(); SafeDelete(fMessageHandlers);

#ifdef R__COMPLETE_MEM_TERMINATION
      SafeDelete(fCanvases);
      SafeDelete(fTasks);
      SafeDelete(fProofs);
      SafeDelete(fDataSets);
      SafeDelete(fClipboard);

      fCleanups->Clear();
      delete fPluginManager; gPluginMgr = fPluginManager = 0;
      delete gClassTable;  gClassTable = 0;
      delete gEnv; gEnv = 0;

      if (fTypes) fTypes->Delete();
      SafeDelete(fTypes);
      if (fGlobals) fGlobals->Delete();
      SafeDelete(fGlobals);
      if (fGlobalFunctions) fGlobalFunctions->Delete();
      SafeDelete(fGlobalFunctions);
      fClasses->Delete();    SafeDelete(fClasses);     // TClass'es must be deleted last
#endif

      // Remove shared libraries produced by the TSystem::CompileMacro() call
      gSystem->CleanCompiledMacros();

      // Cleanup system class
      delete gSystem;

      // Problem deleting the interpreter. Want's to delete objects already
      // deleted in the dtor's above. Crash.
      // It should only close the files and NOT delete.
      SafeDelete(fInterpreter);

#ifdef R__COMPLETE_MEM_TERMINATION
      SafeDelete(fCleanups);
#endif

      // Prints memory stats
      TStorage::PrintStatistics();

      gROOT = 0;
      fgRootInit = kFALSE;
   }
}

//______________________________________________________________________________
void TROOT::AddClass(TClass *cl)
{
   // Add a class to the list and map of classes.
   // This routine is deprecated, use TClass::AddClass directly.

   TClass::AddClass(cl);
}

//______________________________________________________________________________
void TROOT::AddClassGenerator(TClassGenerator *generator)
{
   // Add a class generator.  This generator will be called by TClass::GetClass
   // in case its does not find a loaded rootcint dictionary to request the
   // creation of a TClass object.

   if (!generator) return;
   fClassGenerators->Add(generator);
}

//______________________________________________________________________________
void TROOT::Browse(TBrowser *b)
{
   // Add browsable objects to TBrowser.

   TObject *obj;
   TIter next(fBrowsables);

   while ((obj = (TObject *) next())) {
      const char *opt = next.GetOption();
      if (opt && strlen(opt))
         b->Add(obj, opt);
      else
         b->Add(obj, obj->GetName());
   }
}

//______________________________________________________________________________
Bool_t TROOT::ClassSaved(TClass *cl)
{
// return class status bit kClassSaved for class cl
// This function is called by the SavePrimitive functions writing
// the C++ code for an object.

   if (cl == 0) return kFALSE;
   if (cl->TestBit(TClass::kClassSaved)) return kTRUE;
   cl->SetBit(TClass::kClassSaved);
   return kFALSE;
}

namespace {
   static void R__ListSlowClose(TList *files)
   {
      static TObject harmless;
      TObjLink *cursor = files->FirstLink();
      while (cursor) {
         TDirectory *dir = static_cast<TDirectory*>( cursor->GetObject() );
         if (dir) {
            // In order for the iterator to stay valid, we must
            // prevent the removal of the object (dir) from the list
            // (which is done in TFile::Close).   We can also can not
            // just move to the next iterator since the Close might
            // also (indirectly) remove that file.
            // So we SetObject to a harmless value, so that 'dir'
            // is not seen as part of the list.
            // We will later, remove all the object (see files->Clear()
            cursor->SetObject(&harmless); // this must not be zero otherwise things go wrong.
            dir->Close();
            // Put it back
            cursor->SetObject(dir);
         }
         cursor = cursor->Next();
      };
      // Now were done, clear the list but do not delete the objecs as 
      // they have been moved to the list of closed objects and must be 
      // deleted from there in order to avoid a double delete from a
      // use objects (on the interpreter stack).
      files->Clear("nodelete");  
   }
}

//______________________________________________________________________________
void TROOT::CloseFiles()
{
   // Close any files and sockets that gROOT knows about.
   // This can be used to insures that the files and sockets are closed before any library is unloaded!

   if (fFiles && fFiles->First()) {
      R__ListSlowClose(static_cast<TList*>(fFiles));
   }
   if (fSockets && fSockets->First()) {
      if (0==fCleanups->FindObject(fSockets) ) {
         fCleanups->Add(fSockets);
         fSockets->SetBit(kMustCleanup);
      }
      CallFunc_t *socketCloser = gInterpreter->CallFunc_Factory();
      Long_t offset = 0;
      TClass *socketClass = TClass::GetClass("TSocket");
      gInterpreter->CallFunc_SetFuncProto(socketCloser, socketClass->GetClassInfo(), "Close", "", &offset);
      if (gInterpreter->CallFunc_IsValid(socketCloser)) {
         static TObject harmless;
         TObjLink *cursor = static_cast<TList*>(fSockets)->FirstLink();
         TList notclosed;
         while (cursor) {
            TObject *socket = cursor->GetObject();
            // In order for the iterator to stay valid, we must
            // prevent the removal of the object (dir) from the list
            // (which is done in TFile::Close).   We can also can not
            // just move to the next iterator since the Close might
            // also (indirectly) remove that file.
            // So we SetObject to a harmless value, so that 'dir'
            // is not seen as part of the list.
            // We will later, remove all the object (see files->Clear()
            cursor->SetObject(&harmless); // this must not be zero otherwise things go wrong.

            if (socket->IsA()->InheritsFrom(socketClass)) {
               gInterpreter->CallFunc_Exec(socketCloser, ((char*)socket)+offset);
               // Put the object in the closed list for later deletion.
               socket->SetBit(kMustCleanup);
               fClosedObjects->AddLast(socket);
            } else {
               // Crap ... this is not a socket, likely Proof or something, let's try to find a Close
               Long_t other_offset;
               CallFunc_t *otherCloser = gInterpreter->CallFunc_Factory();
               gInterpreter->CallFunc_SetFuncProto(otherCloser, socket->IsA()->GetClassInfo(), "Close", "", &other_offset);
               if (gInterpreter->CallFunc_IsValid(otherCloser)) {
                  gInterpreter->CallFunc_Exec(otherCloser, ((char*)socket)+other_offset);
                  // Put the object in the closed list for later deletion.
                  socket->SetBit(kMustCleanup);
                  fClosedObjects->AddLast(socket);
               } else {
                  notclosed.AddLast(socket);
               }
               gInterpreter->CallFunc_Delete(otherCloser);
               // Put it back
               cursor->SetObject(socket);
            }
            cursor = cursor->Next();
         }
         // Now were done, clear the list
         fSockets->Clear();
         // Readd the one we did not close
         cursor = notclosed.FirstLink();
         while (cursor) {
            static_cast<TList*>(fSockets)->AddLast(cursor->GetObject());
            cursor = cursor->Next();
         }
      }
      gInterpreter->CallFunc_Delete(socketCloser);
   }
   if (fMappedFiles && fMappedFiles->First()) {
      R__ListSlowClose(static_cast<TList*>(fMappedFiles));
   }
}

//______________________________________________________________________________
TObject *TROOT::FindObject(const TObject *) const
{
// Find an object in one Root folder

   Error("FindObject","Not yet implemented");
   return 0;
}

//______________________________________________________________________________
TObject *TROOT::FindObject(const char *name) const
{
   // Returns address of a ROOT object if it exists
   //
   // If name contains at least one "/" the function calls FindObjectany
   // else
   // This function looks in the following order in the ROOT lists:
   //     - List of files
   //     - List of memory mapped files
   //     - List of functions
   //     - List of geometries
   //     - List of canvases
   //     - List of styles
   //     - List of specials
   //     - List of materials in current geometry
   //     - List of shapes in current geometry
   //     - List of matrices in current geometry
   //     - List of Nodes in current geometry
   //     - Current Directory in memory
   //     - Current Directory on file

   if (name && strstr(name,"/")) return FindObjectAny(name);

   TObject *temp = 0;

   temp   = fFiles->FindObject(name);       if (temp) return temp;
   temp   = fMappedFiles->FindObject(name); if (temp) return temp;
   temp   = fFunctions->FindObject(name);   if (temp) return temp;
   temp   = fGeometries->FindObject(name);  if (temp) return temp;
   temp   = fCanvases->FindObject(name);    if (temp) return temp;
   temp   = fStyles->FindObject(name);      if (temp) return temp;
   temp   = fSpecials->FindObject(name);    if (temp) return temp;
   TIter next(fGeometries);
   TObject *obj;
   while ((obj=next())) {
      temp = obj->FindObject(name);         if (temp) return temp;
   }
   if (gDirectory) temp = gDirectory->Get(name); if (temp) return temp;
   if (gPad) {
      TVirtualPad *canvas = gPad->GetVirtCanvas();
      if (fCanvases->FindObject(canvas)) {  //this check in case call from TCanvas ctor
         temp = canvas->FindObject(name);
         if (!temp && canvas != gPad) temp  = gPad->FindObject(name);
      }
   }
   return temp;
}

//______________________________________________________________________________
TObject *TROOT::FindSpecialObject(const char *name, void *&where)
{
   // Returns address and folder of a ROOT object if it exists
   //
   // This function looks in the following order in the ROOT lists:
   //     - List of files
   //     - List of memory mapped files
   //     - List of functions
   //     - List of geometries
   //     - List of canvases
   //     - List of styles
   //     - List of specials
   //     - List of materials in current geometry
   //     - List of shapes in current geometry
   //     - List of matrices in current geometry
   //     - List of Nodes in current geometry
   //     - Current Directory in memory
   //     - Current Directory on file

   TObject *temp = 0;
   where = 0;

   if (!temp) {
      temp  = fFiles->FindObject(name);
      where = fFiles;
   }
   if (!temp) {
      temp  = fMappedFiles->FindObject(name);
      where = fMappedFiles;
   }
   if (!temp) {
      temp  = fFunctions->FindObject(name);
      where = fFunctions;
   }
   if (!temp) {
      temp  = fCanvases->FindObject(name);
      where = fCanvases;
   }
   if (!temp) {
      temp  = fStyles->FindObject(name);
      where = fStyles;
   }
   if (!temp) {
      temp  = fSpecials->FindObject(name);
      where = fSpecials;
   }
   if (!temp) {
      TObject *glast = fGeometries->Last();
      if (glast) {where = glast; temp = glast->FindObject(name);}
   }
   if (!temp && gDirectory) {
      temp  = gDirectory->Get(name);
      where = gDirectory;
   }
   if (!temp && gPad) {
      TVirtualPad *canvas = gPad->GetVirtCanvas();
      if (fCanvases->FindObject(canvas)) {  //this check in case call from TCanvas ctor
         temp  = canvas->FindObject(name);
         where = canvas;
         if (!temp && canvas != gPad) {
            temp  = gPad->FindObject(name);
            where = gPad;
         }
      }
   }
   if (!temp) return 0;
   if (temp->TestBit(kNotDeleted)) return temp;
   return 0;
}

//______________________________________________________________________________
TObject *TROOT::FindObjectAny(const char *name) const
{
   // Return a pointer to the first object with name starting at //root.
   // This function scans the list of all folders.
   // if no object found in folders, it scans the memory list of all files.

   TObject *obj = fRootFolder->FindObjectAny(name);
   if (obj) return obj;
   return gDirectory->FindObjectAnyFile(name);
}

//______________________________________________________________________________
TObject *TROOT::FindObjectAnyFile(const char *name) const
{
   // Scan the memory lists of all files for an object with name

   TDirectory *d;
   TIter next(GetListOfFiles());
   while ((d = (TDirectory*)next())) {
      // Call explicitly TDirectory::FindObject to restrict the search to the
      // arlready in memory object.
      TObject *obj = d->TDirectory::FindObject(name);
      if (obj) return obj;
   }
   return 0;
}

//______________________________________________________________________________
const char *TROOT::FindObjectClassName(const char *name) const
{
   // Returns class name of a ROOT object including CINT globals.

   // Search first in the list of "standard" objects
   TObject *obj = FindObject(name);
   if (obj) return obj->ClassName();

   // Is it a global variable?
   TGlobal *g = GetGlobal(name);
   if (g) return g->GetTypeName();

   return 0;
}

//______________________________________________________________________________
const char *TROOT::FindObjectPathName(const TObject *) const
{
   // Return path name of obj somewhere in the //root/... path.
   // The function returns the first occurence of the object in the list
   // of folders. The returned string points to a static char array in TROOT.
   // If this function is called in a loop or recursively, it is the
   // user's responsability to copy this string in his area.

   Error("FindObjectPathName","Not yet implemented");
   return "??";
}

//______________________________________________________________________________
static TClass *R__FindSTLClass(const char *name, Bool_t load, Bool_t silent, const char *outername)
{
   // return a TClass object corresponding to 'name' assuming it is an STL container.
   // In particular we looking for possible alternative name (default template
   // parameter, typedefs template arguments, typedefed name).

   TClass *cl = 0;

   // We have not found the STL container yet.
   // First we are going to look for a similar name but different 'default' template
   // parameter (differences due to different STL implementation)

   string defaultname( TClassEdit::ShortType( name, TClassEdit::kDropStlDefault ) ) ;

   if (defaultname != name) {
      cl = (TClass*)gROOT->GetListOfClasses()->FindObject(defaultname.c_str());
      if (load && !cl) cl = gROOT->LoadClass(defaultname.c_str(), silent);
   }

   if (cl==0) {

      // now look for a typedef
      // well for now the typedefing in CINT has some issues
      // for examples if we generated the dictionary for
      //    set<string,someclass> then set<string> is typedef to it (instead of set<string,less<string> >)

      TDataType *objType = gROOT->GetType(name, load);
      if (objType) {
         const char *typedfName = objType->GetTypeName();
         if (typedfName) {
            string defaultTypedefName(TClassEdit::ShortType(typedfName, TClassEdit::kDropStlDefault));

            if (strcmp(typedfName, name) && defaultTypedefName == name) {
               cl = (TClass*)gROOT->GetListOfClasses()->FindObject(typedfName);
               if (load && !cl) cl = gROOT->LoadClass(typedfName, silent);
            }
         }
      }
   }
   if (cl==0) {
      // Try the alternate name where all the typedefs are resolved:

      const char *altname = gInterpreter->GetInterpreterTypeName(name);
      if (altname && strcmp(altname,name)!=0 && strcmp(altname,outername)!=0) {
         cl = TClass::GetClass(altname,load,silent);
      }
   }
   if (cl==0) {
      // Try with Long64_t instead of long long
      string long64name = TClassEdit::GetLong64_Name( name );
      if ( long64name != name && long64name != outername ) return R__FindSTLClass( long64name.c_str(), load, silent, outername);
   }
   if (cl == 0) {
      TString resolvedName = TClassEdit::ResolveTypedef(name,kFALSE).c_str();
      if (resolvedName != name && resolvedName != outername) cl = TClass::GetClass(resolvedName,load,silent);
   }
   if (cl == 0 && (strncmp(name,"std::",5)==0)) {
      // CINT sometime ignores the std namespace for stl containers,
      // so let's try without it.
      if (strlen(name+5)) cl = TClass::GetClass(name+5,load,silent);
   }

   if (load && cl==0) {
      // Create an Emulated class for this container.
      cl = new TClass(defaultname.c_str(), TClass::GetClass("TVirtualStreamerInfo")->GetClassVersion(), 0, 0, -1, -1, silent );
      cl->SetBit(TClass::kIsEmulation);
   }

   return cl;
}

//______________________________________________________________________________
TClass *TROOT::FindSTLClass(const char *name, Bool_t load, Bool_t silent) const
{
   // return a TClass object corresponding to 'name' assuming it is an STL container.
   // In particular we looking for possible alternative name (default template
   // parameter, typedefs template arguments, typedefed name).

   return R__FindSTLClass(name,load,silent,name);
}

//______________________________________________________________________________
TClass *TROOT::GetClass(const char *name, Bool_t load, Bool_t silent) const
{
   // Return pointer to class with name. Obsolete, use TClass::GetClass directly

   return TClass::GetClass(name,load,silent);
}


//______________________________________________________________________________
TClass *TROOT::GetClass(const type_info& typeinfo, Bool_t load, Bool_t silent) const
{
   // Return pointer to class from its name. Obsolete, use TClass::GetClass directly
   // See TClass::GetClass

   return TClass::GetClass(typeinfo,load,silent);
}

//______________________________________________________________________________
TColor *TROOT::GetColor(Int_t color) const
{
   // Return address of color with index color.

   TColor::InitializeColors();
   TObjArray *lcolors = (TObjArray*) GetListOfColors();
   if (!lcolors) return 0;
   if (color < 0 || color >= lcolors->GetSize()) return 0;
   TColor *col = (TColor*)lcolors->At(color);
   if (col && col->GetNumber() == color) return col;
   TIter   next(lcolors);
   while ((col = (TColor *) next()))
      if (col->GetNumber() == color) return col;

   return 0;
}

//______________________________________________________________________________
TCanvas *TROOT::MakeDefCanvas() const
{
   // Return a default canvas.

   return (TCanvas*)gROOT->ProcessLine("TCanvas::MakeDefCanvas();");
}

//______________________________________________________________________________
TDataType *TROOT::GetType(const char *name, Bool_t load) const
{
   // Return pointer to type with name.

   // First try without loading.  We can do that because nothing is
   // ever removed from the list of types. (See TCint::UpdateListOfTypes).
   TDataType* type = (TDataType*)gROOT->GetListOfTypes(kFALSE)->FindObject(name);
   if (type || !load)
      return type;
   else
      return (TDataType*)gROOT->GetListOfTypes(load)->FindObject(name);
}

//______________________________________________________________________________
TFile *TROOT::GetFile(const char *name) const
{
   // Return pointer to file with name.

   return (TFile*)GetListOfFiles()->FindObject(name);
}

//______________________________________________________________________________
TStyle *TROOT::GetStyle(const char *name) const
{
   // Return pointer to style with name

   return (TStyle*)GetListOfStyles()->FindObject(name);
}

//______________________________________________________________________________
TObject *TROOT::GetFunction(const char *name) const
{
   // Return pointer to function with name.

   if (name == 0 || name[0] == 0) {
      return 0;
   }

   TObject *f1 = fFunctions->FindObject(name);
   if (f1) return f1;

   gROOT->ProcessLine("TF1::InitStandardFunctions();");

   return fFunctions->FindObject(name);
}

//______________________________________________________________________________
TGlobal *TROOT::GetGlobal(const char *name, Bool_t load) const
{
   // Return pointer to global variable by name. If load is true force
   // reading of all currently defined globals from CINT (more expensive).

   return (TGlobal *)gROOT->GetListOfGlobals(load)->FindObject(name);
}

//______________________________________________________________________________
TGlobal *TROOT::GetGlobal(const TObject *addr, Bool_t load) const
{
   // Return pointer to global variable with address addr. If load is true
   // force reading of all currently defined globals from CINT (more
   // expensive).

   TIter next(gROOT->GetListOfGlobals(load));

   TGlobal *g;
   while ((g = (TGlobal*) next())) {
      const char *t = g->GetFullTypeName();
      if (!strncmp(t, "class", 5) || !strncmp(t, "struct", 6)) {
         int ptr = 0;
         if (t[strlen(t)-1] == '*') ptr = 1;
         if (ptr) {
            if (*(Long_t *)g->GetAddress() == (Long_t)addr) return g;
         } else {
            if ((Long_t)g->GetAddress() == (Long_t)addr) return g;
         }
      }
   }
   return 0;
}

//______________________________________________________________________________
TFunction *TROOT::GetGlobalFunction(const char *function, const char *params,
                                    Bool_t load)
{
   // Return pointer to global function by name. If params != 0
   // it will also resolve overloading. If load is true force reading
   // of all currently defined global functions from CINT (more expensive).
   // The param string must be of the form: "3189,\"aap\",1.3".

   if (!params)
      return (TFunction *)GetListOfGlobalFunctions(load)->FindObject(function);
   else {
      if (!fInterpreter)
         Fatal("GetGlobalFunction", "fInterpreter not initialized");

      TFunction *f;
      TIter      next(GetListOfGlobalFunctions(load));

      TString mangled = gInterpreter->GetMangledName(0, function, params);
      while ((f = (TFunction *) next())) {
         if (mangled == f->GetMangledName()) return f;
      }

      return 0;
   }
}

//______________________________________________________________________________
TFunction *TROOT::GetGlobalFunctionWithPrototype(const char *function,
                                               const char *proto, Bool_t load)
{
   // Return pointer to global function by name. If proto != 0
   // it will also resolve overloading. If load is true force reading
   // of all currently defined global functions from CINT (more expensive).
   // The proto string must be of the form: "int, char*, float".

   if (!proto)
      return (TFunction *)GetListOfGlobalFunctions(load)->FindObject(function);
   else {
      if (!fInterpreter)
         Fatal("GetGlobalFunctionWithPrototype", "fInterpreter not initialized");

      TFunction *f;
      TIter      next(GetListOfGlobalFunctions(load));

      TString mangled = gInterpreter->GetMangledNameWithPrototype(0,
                                                                     function,
                                                                     proto);
      while ((f = (TFunction *) next())) {
         if (mangled == f->GetMangledName()) return f;
      }
      return 0;
   }
}

//______________________________________________________________________________
TObject *TROOT::GetGeometry(const char *name) const
{
   // Return pointer to Geometry with name

   return GetListOfGeometries()->FindObject(name);
}

//______________________________________________________________________________
TCollection *TROOT::GetListOfGlobals(Bool_t load)
{
   // Return list containing the TGlobals currently defined.
   // Since globals are created and deleted during execution of the
   // program, we need to update the list of globals every time we
   // execute this method. However, when calling this function in
   // a (tight) loop where no interpreter symbols will be created
   // you can set load=kFALSE (default).

   if (!fGlobals) {
      fGlobals = new THashTable(100, 3);
      load = kTRUE;
   }

   if (!fInterpreter)
      Fatal("GetListOfGlobals", "fInterpreter not initialized");

   if (load)
      gInterpreter->UpdateListOfGlobals();

   return fGlobals;
}

//______________________________________________________________________________
TCollection *TROOT::GetListOfGlobalFunctions(Bool_t load)
{
   // Return list containing the TFunctions currently defined.
   // Since functions are created and deleted during execution of the
   // program, we need to update the list of functions every time we
   // execute this method. However, when calling this function in
   // a (tight) loop where no interpreter symbols will be created
   // you can set load=kFALSE (default).

   if (!fGlobalFunctions) {
      fGlobalFunctions = new THashTable(100, 3);
      load = kTRUE;
   }

   if (!fInterpreter)
      Fatal("GetListOfGlobalFunctions", "fInterpreter not initialized");

   if (load)
      gInterpreter->UpdateListOfGlobalFunctions();

   return fGlobalFunctions;
}

//______________________________________________________________________________
TCollection *TROOT::GetListOfTypes(Bool_t load)
{
   // Return list containing all TDataTypes (typedefs) currently defined.
   // Since types can be added and removed during execution of the
   // program, we need to update the list of types every time we
   // execute this method. However, when calling this function in
   // a (tight) loop where no new types will be created
   // you can set load=kFALSE (default).

   if (!fTypes) {
      fTypes = new THashTable(100, 3);
      load = kTRUE;
      TDataType::AddBuiltins(fTypes);
   }

   if (!fInterpreter)
      Fatal("GetListOfTypes", "fInterpreter not initialized");

   if (load) {
///      printf("calling Update ListOfTypes\n");
      gInterpreter->UpdateListOfTypes();
///      printf("after calling Update ListOfTypes\n");
   }

   return fTypes;
}


//______________________________________________________________________________
void TROOT::Idle(UInt_t idleTimeInSec, const char *command)
{
   // Execute command when system has been idle for idleTimeInSec seconds.

   if (!fApplication)
      TApplication::CreateApplication();

   if (idleTimeInSec <= 0)
      fApplication->RemoveIdleTimer();
   else
      fApplication->SetIdleTimer(idleTimeInSec, command);
}

//______________________________________________________________________________
static TClass* R__GetClassIfKnown(const char* className) 
{
   // Check whether className is a known class, and only autoload
   // if we can. Helper function for TROOT::IgnoreInclude().

   // Check whether the class is available for auto-loading first:
   const char* libsToLoad = gInterpreter->GetClassSharedLibs(className);
   TClass* cla = 0;
   if (libsToLoad) {
      // trigger autoload, and only create TClass in this case.
      return TClass::GetClass(className);
   } else if (gROOT->GetListOfClasses()
              && (cla = (TClass*)gROOT->GetListOfClasses()->FindObject(className))) {
      // cla assigned in if statement
   } else if (gClassTable->FindObject(className)) {
      return TClass::GetClass(className);
   }
   return cla;
}

//______________________________________________________________________________
Int_t TROOT::IgnoreInclude(const char *fname, const char * /*expandedfname*/)
{
   // Return 1 if the name of the given include file corresponds to a class that
   //  is known to ROOT, e.g. "TLorentzVector.h" versus TLorentzVector.

   if (fname == 0) return 0;

   TString stem(fname);
   // Remove extension if any, ignore files with extension not being .h*
   Int_t where = stem.Last('.');
   if (where != kNPOS) {
      if (stem.EndsWith(".so") || stem.EndsWith(".sl") ||
          stem.EndsWith(".dl") || stem.EndsWith(".a")  ||
          stem.EndsWith(".dll", TString::kIgnoreCase))
         return 0;
      stem.Remove(where);
   }

   TString className = gSystem->BaseName(stem);
   TClass* cla = R__GetClassIfKnown(className);
   if (!cla) {
      // Try again with modifications to the file name:
      className = stem;
      className.ReplaceAll("/", "::");
      className.ReplaceAll("\\", "::");
      if (className.Contains(":::")) {
         // "C:\dir" becomes "C:::dir".
         // fname corresponds to whatever is stated after #include and
         // a full path name usually means that it's not a regular #include
         // but e.g. a ".L", so we can assume that this is not a header of
         // a class in a namespace (a global-namespace class would have been
         // detected already before).
         return 0;
      }
      cla = R__GetClassIfKnown(className);
   }

   if (!cla) {
      return 0;
   }

   // cla is valid, check wether it's actually in the header of the same name:
   if (cla->GetDeclFileLine() <= 0) return 0; // to a void an error with VisualC++
   TString decfile = gSystem->BaseName(cla->GetDeclFileName());
   if (decfile != gSystem->BaseName(fname)) {
      return 0;
   }
   return 1;
}

//______________________________________________________________________________
void TROOT::InitSystem()
{
   // Initialize operating system interface.

   if (gSystem == 0) {
#if defined(R__UNIX)
      gSystem = new TUnixSystem;
#elif defined(R__WIN32)
      gSystem = new TWinNTSystem;
#else
      gSystem = new TSystem;
#endif

      if (gSystem->Init())
         fprintf(stderr, "Fatal in <TROOT::InitSystem>: can't init operating system layer\n");

      if (!gSystem->HomeDirectory()) {
         fprintf(stderr, "Fatal in <TROOT::InitSystem>: HOME directory not set\n");
         fprintf(stderr, "Fix this by defining the HOME shell variable\n");
      }

      // read default files
      gEnv = new TEnv(".rootrc");

      gDebug = gEnv->GetValue("Root.Debug", 0);

      //By default the zipmode is 1 (see Bits.h)
      Int_t zipmode = gEnv->GetValue("Root.ZipMode",1);
      if (zipmode !=1) R__SetZipMode(zipmode);

      const char *sdeb;
      if ((sdeb = gSystem->Getenv("ROOTDEBUG")))
         gDebug = atoi(sdeb);

      if (gDebug > 0 && isatty(2))
         fprintf(stderr, "Info in <TROOT::InitSystem>: running with gDebug = %d\n", gDebug);

      if (gEnv->GetValue("Root.MemStat", 0))
         TStorage::EnableStatistics();
      int msize = gEnv->GetValue("Root.MemStat.size", -1);
      int mcnt  = gEnv->GetValue("Root.MemStat.cnt", -1);
      if (msize != -1 || mcnt != -1)
         TStorage::EnableStatistics(msize, mcnt);

      fgMemCheck = gEnv->GetValue("Root.MemCheck", 0);

      TObject::SetObjectStat(gEnv->GetValue("Root.ObjectStat", 0));
   }
}

//______________________________________________________________________________
void TROOT::InitThreads()
{
   // Load and initialize thread library.

   if (gEnv->GetValue("Root.UseThreads", 0)) {
      char *path;
      if ((path = gSystem->DynamicPathName("libThread", kTRUE))) {
         delete [] path;
         LoadClass("TThread", "Thread");
      }
   }
}

//______________________________________________________________________________
TClass *TROOT::LoadClass(const char *requestedname, Bool_t silent) const
{
   // Helper function used by TClass::GetClass().
   // This function attempts to load the dictionary for 'classname'
   // either from the TClassTable or from the list of generator.
   // If silent is 'true', do not warn about missing dictionary for the class.
   // (typically used for class that are used only for transient members)

   // This function does not (and should not) attempt to check in the
   // list of loaded classes or in the typedef.


   // We need to cache the requested name as in some case this function is
   // called with gROOT->LoadClass(cl->GetName()) and the loading of a library,
   // for example via the autoloader, can result in our argument becoming invalid.
   // In addition the call to the dictionary function (dict()) might also have
   // the same effect (change/delete requestedname).
   TString classname(requestedname);

   VoidFuncPtr_t dict = TClassTable::GetDict(classname);

   TString resolved;

   if (!dict) {
      // Try to remove the ROOT typedefs
      resolved = TClassEdit::ResolveTypedef(classname,kTRUE);
      if (resolved != classname) {
         dict = TClassTable::GetDict(resolved.Data());
      } else {
         resolved.Clear();
      }
   }
   if (!dict) {
      if (gInterpreter->AutoLoad(classname)) {
         dict = TClassTable::GetDict(classname);
         if (!dict) {
            // Try the typedefs again.
            if (resolved.Length()) {
               dict = TClassTable::GetDict(resolved.Data());
            }
         }
      }
   }

   if (dict) {
      (dict)();
      TClass *ncl = TClass::GetClass(classname, kFALSE, silent);
      if (ncl) ncl->PostLoadCheck();
      return ncl;
   }

   TIter next(fClassGenerators);
   TClassGenerator *gen;
   while ((gen = (TClassGenerator*) next())) {
      TClass *cl = gen->GetClass(classname, kTRUE, silent);
      if (cl) {
         cl->PostLoadCheck();
         return cl;
      }
   }
   return 0;
}

//______________________________________________________________________________
Int_t TROOT::LoadClass(const char * /*classname*/, const char *libname,
                       Bool_t check)
{
   // Check if class "classname" is known to the interpreter (in fact,
   // this check is not needed anymore, so classname is ignored). If
   // not it will load library "libname". If the library name does
   // not start with "lib", "lib" will be prepended and a search will
   // be made in the DynamicPath (see .rootrc). If not found a search
   // will be made on libname (without "lib" prepended) and if not found
   // a direct try of libname will be made (in case it contained an
   // absolute path).
   // If check is true it will only check if libname exists and is
   // readable.
   // Returns 0 on successful loading, -1 in case libname does not
   // exist or in case of error and -2 in case of version mismatch.

   Int_t err = -1;

   char *path;
   TString lib = libname;
   if (!lib.BeginsWith("lib"))
      lib = "lib" + lib;
   if ((path = gSystem->DynamicPathName(lib, kTRUE))) {
      if (check)
         err = 0;
      else {
         err = gSystem->Load(path, 0, kTRUE);
      }
      delete [] path;
   } else {
      if (check) {
         FileStat_t stat;
         if (!gSystem->GetPathInfo(libname, stat)) {
            if (R_ISREG(stat.fMode) &&
                !gSystem->AccessPathName(libname, kReadPermission))
               err = 0;
            else
               err = -1;
         } else
            err = -1;
      } else {
         err = gSystem->Load(libname, 0, kTRUE);
      }
   }

   if (err == 0 && !check) {
      GetListOfTypes(kTRUE);
   }

   if (err == -1) {
      //Error("LoadClass", "library %s could not be loaded", libname);
   }

   if (err == 1) {
      //Error("LoadClass", "library %s already loaded, but class %s unknown",
      //      libname, classname);
      err = 0;
   }

   return err;
}

//______________________________________________________________________________
void TROOT::ls(Option_t *option) const
{
   // To list all objects of the application.
   // Loop on all objects created in the ROOT linked lists.
   // Objects may be files and windows or any other object directly
   // attached to the ROOT linked list.

//   TObject::SetDirLevel();
//   GetList()->R__FOR_EACH(TObject,ls)(option);
   TDirectory::ls(option);
}

//______________________________________________________________________________
Int_t TROOT::LoadMacro(const char *filename, int *error, Bool_t check)
{
   // Load a macro in the interpreter's memory. Equivalent to the command line
   // command ".L filename". If the filename has "+" or "++" appended
   // the macro will be compiled by ACLiC. The filename must have the format:
   // [path/]macro.C[+|++[g|O]].
   // The possible error codes are defined by TInterpreter::EErrorCode.
   // If check is true it will only check if filename exists and is
   // readable.
   // Returns 0 on successful loading and -1 in case filename does not
   // exist or in case of error.

   Int_t err = -1;
   Int_t lerr, *terr;
   if (error)
      terr = error;
   else
      terr = &lerr;

   if (fInterpreter) {
      TString aclicMode;
      TString arguments;
      TString io;
      TString fname = gSystem->SplitAclicMode(filename, aclicMode, arguments, io);

      if (arguments.Length()) {
         Warning("LoadMacro", "argument(%s) ignored in %s", arguments.Data(), GetMacroPath());
      }
      char *mac = gSystem->Which(GetMacroPath(), fname, kReadPermission);
      if (!mac) {
         if (!check)
            Error("LoadMacro", "macro %s not found in path %s", fname.Data(), GetMacroPath());
         *terr = TInterpreter::kFatal;
      } else {
         err = 0;
         if (!check) {
            fname = mac;
            fname += aclicMode;
            fname += io;
            gInterpreter->LoadMacro(fname.Data(), (TInterpreter::EErrorCode*)terr);
            if (*terr)
               err = -1;
            //else   // maybe not needed (RDM)
            //   GetListOfTypes(kTRUE);
         }
      }
      delete [] mac;
   }
   return err;
}

//______________________________________________________________________________
Long_t TROOT::Macro(const char *filename, Int_t *error, Bool_t padUpdate)
{
   // Execute a macro in the interpreter. Equivalent to the command line
   // command ".x filename". If the filename has "+" or "++" appended
   // the macro will be compiled by ACLiC. The filename must have the format:
   // [path/]macro.C[+|++[g|O]][(args)].
   // The possible error codes are defined by TInterpreter::EErrorCode.
   // If padUpdate is true (default) update the current pad.
   // Returns the macro return value.

   Long_t result = 0;

   if (fInterpreter) {
      TString aclicMode;
      TString arguments;
      TString io;
      TString fname = gSystem->SplitAclicMode(filename, aclicMode, arguments, io);

      char *mac = gSystem->Which(GetMacroPath(), fname, kReadPermission);
      if (!mac) {
         Error("Macro", "macro %s not found in path %s", fname.Data(), GetMacroPath());
         if (error)
            *error = TInterpreter::kFatal;
      } else {
         fname = mac;
         fname += aclicMode;
         fname += arguments;
         fname += io;
         result = gInterpreter->ExecuteMacro(fname, (TInterpreter::EErrorCode*)error);
      }
      delete [] mac;

      if (padUpdate && gPad)
         gPad->Update();
   }

   return result;
}

//______________________________________________________________________________
void  TROOT::Message(Int_t id, const TObject *obj)
{
   // Process message id called by obj.

   TIter next(fMessageHandlers);
   TMessageHandler *mh;
   while ((mh = (TMessageHandler*)next())) {
      mh->HandleMessage(id,obj);
   }
}

//______________________________________________________________________________
Long_t TROOT::ProcessLine(const char *line, Int_t *error)
{
   // Process interpreter command via TApplication::ProcessLine().
   // On Win32 the line will be processed asynchronously by sending
   // it to the CINT interpreter thread. For explicit synchronous processing
   // use ProcessLineSync(). On non-Win32 platforms there is no difference
   // between ProcessLine() and ProcessLineSync().
   // The possible error codes are defined by TInterpreter::EErrorCode. In
   // particular, error will equal to TInterpreter::kProcessing until the
   // CINT interpreted thread has finished executing the line.
   // Returns the result of the command, cast to a Long_t.

   TString sline = line;
   sline = sline.Strip(TString::kBoth);

   if (!fApplication)
      TApplication::CreateApplication();

   return fApplication->ProcessLine(sline, kFALSE, error);
}

//______________________________________________________________________________
Long_t TROOT::ProcessLineSync(const char *line, Int_t *error)
{
   // Process interpreter command via TApplication::ProcessLine().
   // On Win32 the line will be processed synchronously (i.e. it will
   // only return when the CINT interpreter thread has finished executing
   // the line). On non-Win32 platforms there is no difference between
   // ProcessLine() and ProcessLineSync().
   // The possible error codes are defined by TInterpreter::EErrorCode.
   // Returns the result of the command, cast to a Long_t.

   TString sline = line;
   sline = sline.Strip(TString::kBoth);

   if (!fApplication)
      TApplication::CreateApplication();

   return fApplication->ProcessLine(sline, kTRUE, error);
}

//______________________________________________________________________________
Long_t TROOT::ProcessLineFast(const char *line, Int_t *error)
{
   // Process interpreter command directly via CINT interpreter.
   // Only executable statements are allowed (no variable declarations),
   // In all other cases use TROOT::ProcessLine().
   // The possible error codes are defined by TInterpreter::EErrorCode.

   TString sline = line;
   sline = sline.Strip(TString::kBoth);

   if (!fApplication)
      TApplication::CreateApplication();

   Long_t result = 0;

   if (fInterpreter) {
      TInterpreter::EErrorCode *code = (TInterpreter::EErrorCode*)error;
      result = gInterpreter->Calc(sline, code);
   }

   return result;
}

//______________________________________________________________________________
void TROOT::ReadSvnInfo()
{
   // Read Subversion revision information and branch name from the
   // etc/svnrev.txt file.

   fSvnRevision = 0;
#ifdef ROOT_SVN_REVISION
   fSvnRevision = ROOT_SVN_REVISION;
#endif
#ifdef ROOT_SVN_BRANCH
   fSvnBranch = ROOT_SVN_BRANCH;
#endif

   TString svninfo = "svninfo.txt";
   char *filename = 0;
#ifdef ROOTETCDIR
   filename = gSystem->ConcatFileName(ROOTETCDIR, svninfo);
#else
   TString etc = gRootDir;
#ifdef WIN32
   etc += "\\etc";
#else
   etc += "/etc";
#endif
#if defined(R__MACOSX) && (TARGET_OS_IPHONE || TARGET_IPHONE_SIMULATOR)
   // on iOS etc does not exist and svninfo resides in $ROOTSYS
   etc = gRootDir;
#endif
   filename = gSystem->ConcatFileName(etc, svninfo);
#endif

   FILE *fp = fopen(filename, "r");
   if (fp) {
      TString s;
      // read branch name
      s.Gets(fp);
      fSvnBranch = s;
      // read revision number
      s.Gets(fp);
      Int_t r = s.Atoi();
      if (r > 0)
         fSvnRevision = r;
      // read date/time make was run
      s.Gets(fp);
      fSvnDate = s;
      fclose(fp);
   }
   delete [] filename;
}

//______________________________________________________________________________
const char *TROOT::GetSvnDate()
{
   // Return date/time make was run.

   if (fSvnDate == "") {
      Int_t iday,imonth,iyear, ihour, imin;
      static const char *months[] = { "Jan", "Feb", "Mar", "Apr", "May", "Jun",
                                      "Jul", "Aug", "Sep", "Oct", "Nov", "De" };
      Int_t idate = gROOT->GetBuiltDate();
      Int_t itime = gROOT->GetBuiltTime();
      iday   = idate%100;
      imonth = (idate/100)%100;
      iyear  = idate/10000;
      ihour  = itime/100;
      imin   = itime%100;
      fSvnDate.Form("%s %02d %4d, %02d:%02d:00", months[imonth-1], iday, iyear, ihour, imin);
   }
   return fSvnDate;
}

//______________________________________________________________________________
void TROOT::RefreshBrowsers()
{
   // Refresh all browsers. Call this method when some command line
   // command or script has changed the browser contents. Not needed
   // for objects that have the kMustCleanup bit set. Most useful to
   // update browsers that show the file system or other objects external
   // to the running ROOT session.

   TIter next(GetListOfBrowsers());
   TBrowser *b;
   while ((b = (TBrowser*) next()))
      b->SetRefreshFlag(kTRUE);
}

//______________________________________________________________________________
void TROOT::RemoveClass(TClass *oldcl)
{
   // Remove a class from the list and map of classes.
   // This routine is deprecated, use TClass::RemoveClass directly.

   TClass::RemoveClass(oldcl);
}

//______________________________________________________________________________
void TROOT::Reset(Option_t *option)
{
   // Delete all global interpreter objects created since the last call to Reset
   //
   // If option="a" is set reset to startup context (i.e. unload also
   // all loaded files, classes, structs, typedefs, etc.).
   //
   // This function is typically used at the beginning (or end) of an unnamed macro
   // to clean the environment.
   //
   // IMPORTANT WARNING:
   // Do not use this call from within any function (neither compiled nor
   // interpreted.  This should only be used from a unnamed macro
   // (which starts with a { (curly braces)  ).  For example, using TROOT::Reset
   // from within an interpreted function will lead to the unloading of the
   // dictionary and source file, including the one defining the function being
   // executed.
   //

   if (IsExecutingMacro()) return;  //True when TMacro::Exec runs
   if (fInterpreter) {
      if (!strncmp(option, "a", 1)) {
         fInterpreter->Reset();
         fInterpreter->SaveContext();
      } else
         gInterpreter->ResetGlobals();

      if (fGlobals) fGlobals->Delete();
      if (fGlobalFunctions) fGlobalFunctions->Delete();

      SaveContext();
   }
}

//______________________________________________________________________________
void TROOT::SaveContext()
{
   // Save the current interpreter context.

   if (fInterpreter)
      gInterpreter->SaveGlobalsContext();
}

//______________________________________________________________________________
void TROOT::SetCutClassName(const char *name)
{
   // Set the default graphical cut class name for the graphics editor
   // By default the graphics editor creates an instance of a class TCutG.
   // This function may be called to specify a different class that MUST
   // derive from TCutG

   if (!name) {
      Error("SetCutClassName","Invalid class name");
      return;
   }
   TClass *cl = TClass::GetClass(name);
   if (!cl) {
      Error("SetCutClassName","Unknown class:%s",name);
      return;
   }
   if (!cl->InheritsFrom("TCutG")) {
      Error("SetCutClassName","Class:%s does not derive from TCutG",name);
      return;
   }
   fCutClassName = name;
}

//______________________________________________________________________________
void TROOT::SetEditorMode(const char *mode)
{
   // Set editor mode

   fEditorMode = 0;
   if (strlen(mode) == 0) return;
   if (!strcmp(mode,"Arc"))      {fEditorMode = kArc;        return;}
   if (!strcmp(mode,"Line"))     {fEditorMode = kLine;       return;}
   if (!strcmp(mode,"Arrow"))    {fEditorMode = kArrow;      return;}
   if (!strcmp(mode,"Button"))   {fEditorMode = kButton;     return;}
   if (!strcmp(mode,"Diamond"))  {fEditorMode = kDiamond;    return;}
   if (!strcmp(mode,"Ellipse"))  {fEditorMode = kEllipse;    return;}
   if (!strcmp(mode,"Pad"))      {fEditorMode = kPad;        return;}
   if (!strcmp(mode,"Pave"))     {fEditorMode = kPave;       return;}
   if (!strcmp(mode,"PaveLabel")){fEditorMode = kPaveLabel;  return;}
   if (!strcmp(mode,"PaveText")) {fEditorMode = kPaveText;   return;}
   if (!strcmp(mode,"PavesText")){fEditorMode = kPavesText;  return;}
   if (!strcmp(mode,"PolyLine")) {fEditorMode = kPolyLine;   return;}
   if (!strcmp(mode,"CurlyLine")){fEditorMode = kCurlyLine;  return;}
   if (!strcmp(mode,"CurlyArc")) {fEditorMode = kCurlyArc;   return;}
   if (!strcmp(mode,"Text"))     {fEditorMode = kText;       return;}
   if (!strcmp(mode,"Marker"))   {fEditorMode = kMarker;     return;}
   if (!strcmp(mode,"CutG"))     {fEditorMode = kCutG;       return;}
}

//______________________________________________________________________________
void TROOT::SetStyle(const char *stylename)
{
   // Change current style to style with name stylename

   TString style_name = stylename;

   TStyle *style = GetStyle(style_name);
   if (style) style->cd();
   else       Error("SetStyle","Unknown style:%s",style_name.Data());
}


//-------- Static Member Functions ---------------------------------------------


//______________________________________________________________________________
Int_t TROOT::DecreaseDirLevel()
{
   // Decrease the indentation level for ls().
   return --fgDirLevel;
}

//______________________________________________________________________________
Int_t TROOT::GetDirLevel()
{
   //return directory level
   return fgDirLevel;
}

//______________________________________________________________________________
const char *TROOT::GetMacroPath()
{
   // Get macro search path. Static utility function.

   TString &macroPath = ROOT::GetMacroPath();

   if (macroPath.Length() == 0) {
      macroPath = gEnv->GetValue("Root.MacroPath", (char*)0);
#if defined(R__WIN32)
      macroPath.ReplaceAll("; ", ";");
#else
      macroPath.ReplaceAll(": ", ":");
#endif
      if (macroPath.Length() == 0)
#if !defined(R__WIN32)
   #ifdef ROOTMACRODIR
         macroPath = ".:" ROOTMACRODIR;
   #else
         macroPath = TString(".:") + gRootDir + "/macros";
   #endif
#else
   #ifdef ROOTMACRODIR
         macroPath = ".;" ROOTMACRODIR;
   #else
         macroPath = TString(".;") + gRootDir + "/macros";
   #endif
#endif
   }

   return macroPath;
}

//______________________________________________________________________________
void TROOT::SetMacroPath(const char *newpath)
{
   // Set or extend the macro search path. Static utility function.
   // If newpath=0 or "" reset to value specified in the rootrc file.

   TString &macroPath = ROOT::GetMacroPath();

   if (!newpath || !*newpath)
      macroPath = "";
   else
      macroPath = newpath;
}

//______________________________________________________________________________
Int_t TROOT::IncreaseDirLevel()
{
   // Increase the indentation level for ls().
   return ++fgDirLevel;
}

//______________________________________________________________________________
void TROOT::IndentLevel()
{
   // Functions used by ls() to indent an object hierarchy.

   for (int i = 0; i < fgDirLevel; i++) cout.put(' ');
}

//______________________________________________________________________________
Bool_t TROOT::Initialized()
{
   // Return kTRUE if the TROOT object has been initialized.
   return fgRootInit;
}

//______________________________________________________________________________
Bool_t TROOT::MemCheck()
{
   // Return kTRUE if the memory leak checker is on.
   return fgMemCheck;
}

//______________________________________________________________________________
void TROOT::SetDirLevel(Int_t level)
{
   // Return Indentation level for ls().
   fgDirLevel = level;
}

//______________________________________________________________________________
Int_t TROOT::ConvertVersionCode2Int(Int_t code)
{
   // Convert version code to an integer, i.e. 331527 -> 51507.

   return 10000*(code>>16) + 100*((code&65280)>>8) + (code&255);
}

//______________________________________________________________________________
Int_t TROOT::ConvertVersionInt2Code(Int_t v)
{
   // Convert version as an integer to version code as used in RVersion.h.

   int a = v/10000;
   int b = (v - a*10000)/100;
   int c = v - a*10000 - b*100;
   return (a << 16) + (b << 8) + c;
}

//______________________________________________________________________________
Int_t TROOT::RootVersionCode()
{
   // Return ROOT version code as defined in RVersion.h.

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