ROOT logo
// @(#)root/memstat:$Name$:$Id: TMemStat.cxx 26028 2008-10-30 20:09:44Z brun $
// Author: M.Ivanov   18/06/2007 -- Anar Manafov (A.Manafov@gsi.de) 29/04/2008

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

////////////////////////////////////////////////////////////////////////////////
/* BEGIN_HTML
<center><h2>The TMemStat class</h2></center>
TMemStat  - a class for visualization of the memory usage.
<br/>
Principle:
Hook functions for malloc and free are used.
All calls to malloc and free are caught and the statistical information is collected.
The information is collected per stack trace (Unique identifier and per functions).<br/>
Following information are collected as function of time:
<ul>
    <li>Total number of allocations</li>
    <li>Total allocation size</li>
    <li>Allocation count</li>
    <li>Allocation size</li>
</ul>
How to use it:<br/>
To create a memstat object use the following:
<pre>
    TMemStat memstat("new");
</pre>
Possible options:
<ul>
    <li> "new" - Start new data collection. In the current release a hard-coded "memstat.root" file will be created or overwritten if exists.</li>
    <li> "read" - "read" - analyze previously collected data.</li>
    <li>"gnubuildin" - if declared, then TMemStat will use gcc build-in function, otherwise glibc backtrace will be used.</li>
</ul>
A user may want to request for adding the named memory stamp:
<pre>
    memstat.AddStamp("STEMPNAME")
</pre>
The file "memstat.root" is created after destruction of object.<br/>
This class supports following  functions for standard user:
<ul>
    <li> Report </li>
    <li> Draw </li>
    <li> SelectCode(libname, functionname) </li>
    <li> SelectStack() </li>
</ul>
The various format options to draw a Graph  can be accessed calling
<pre>
    TMemStat memstat;
    memstat.Report("?")
</pre>

Supported options for TMemStat::Report:
<ul>
    <li> order     : 0 - increasing 1 - decreasing</li>
    <li> sortstat  : 0 - TotalAllocCount 1 -  TotalAlocSize  2 - AllocCount 3 - AllocSize</li>
    <li> sortstamp : 0 - Current 1 -  MaxSize  2 - MaxCount</li>
    <li> sortdeep  : (0-inf) number of info to print</li>
    <li> stackdeep : (0-inf) deepness of stack</li>
    <li> Example   : order 0 sortstat 3 sortstamp 0 sortdeep 10 stackdeep 5 maxlength 50 </li>
</ul>


The picture below gives an example:
END_HTML
BEGIN_MACRO(source)
{
   {
      TMemStat memstat("new,gnubuildin");

      for (Int_t i=0;i<11000;i++) {
         TObjString * object = new TObjString(Form("Object%d",i));
         if (i%2) delete object;
      }
      for (Int_t i=0;i<12000;i++) {
         TString * object2 = new TString(i);
         if (i%2) delete object2;
      }
      for (Int_t i=0;i<1300;i++) {
         TClonesArray  *array = new TClonesArray("TVectorD");
         //array.ExpandCreatFast(i);
      }
   }

   TMemStat report;
   report->Report();
}
END_MACRO */
////////////////////////////////////////////////////////////////////////////////

// STD
#include <map>
#include <vector>
#include <iostream>
// ROOT
#include "TTree.h"
#include "TMath.h"
#include "TArrayI.h"
#include "TBits.h"
#include "TDirectory.h"
//#include "TCanvas.h"
//#include "TPad.h"
#include "TAxis.h"
#include "TGraph.h"
#include "TLegend.h"
#include "TText.h"
//#include "TLine.h"
#include "THStack.h"
#include "TSystem.h"
// Memstat
#include "TMemStat.h"
#include "TMemStatInfo.h"
#include "TMemStatManager.h"
#include "TMemStatHelpers.h"


ClassImp(TMemStat)

using namespace std;
using namespace Memstat;

typedef vector<Long64_t> Long64Vector_t;
typedef vector<Double_t> DoubleVector_t;

_INIT_TOP_STECK;

struct SFillSelection: public binary_function<
         TMemStatManager::CodeInfoContainer_t::value_type,
         TMemStat::ESelection,
         TMemStat::Selection_t::value_type>
{
   TMemStat::Selection_t::value_type operator() (
      const TMemStatManager::CodeInfoContainer_t::value_type &_code_info,
      TMemStat::ESelection _Selection ) const
   {
      switch ( _Selection )
      {
      case TMemStat::kFunction:
         return _code_info.fFunction.Data();
      case TMemStat::kLibrary:
         // we need only names of libraries
         return gSystem->BaseName(_code_info.fLib.Data());
      default:
         return string();
      }
   }
};

//______________________________________________________________________________
TMemStat::TMemStat(Option_t* option):
      TObject(),
      fSortStat(kAllocSize),
      fSortStamp(kCurrent),
      fSortDeep(10),
      fStackDeep(20),
      fMaxStringLength(50),
      fSelected(0),
      fIsActive(kFALSE),
      fOrder(kFALSE),
      fSelectedCodeBitmap(NULL),
      fSelectedStackBitmap(NULL),
      fStampArray(NULL),
      fArray(NULL),
      fArrayGraphics(NULL),
      fTree(NULL),
      fTreeSys(NULL),
      fStackSummary(NULL),
      fManager(NULL)
{
   // Supported options:
   //    "new" - start to collect memory allocations stamps
   //    "read" - analyze previously collected data
   //    "gnubuildin" - if declared, then TMemStat will use gcc build-in function,
   //                      otherwise glibc backtrace will be used
   //
   // Default: "read"
   // Note: Currently TMemStat uses a hard-coded output file name (for writing/reading) = "memstat.root";

   // It marks the highest used stack address.
   _GET_TO_STECK;

   //preserve context. When exiting will restore the current directory
   TDirectory::TContext context(gDirectory);

   string opt(option);
   transform( opt.begin(), opt.end(), opt.begin(),
              Memstat::ToLower_t() );

   if ( opt.find("new") != string::npos) // Processing "NEW"
   {
      SetAutoStamp();
      const Bool_t useBuildin = (opt.find("gnubuildin") != string::npos)? kTRUE: kFALSE;
      TMemStatManager::GetInstance()->SetUseGNUBuildinBacktrace(useBuildin);
      TMemStatManager::GetInstance()->Enable();
      // set this variable only if "NEW" mode is active
      fIsActive = kTRUE;
   }
   else if ( opt.find("read") != string::npos) // Processing "READ"
   {
      // GetData from existing file
      GetMemStat("memstat.root", -1);

      // default disabling
      fDisablePrintLib.SetOwner();
      fDisablePrintLib.AddLast(new TObjString("libRIO"));
      fDisablePrintCode.SetOwner();
      fDisablePrintCode.AddLast(new TObjString("TClass::Streamer"));
      // set default option
      ProcessOption("order 0 sortstat 3 sortstamp 0 sortdeep 30 stackdeep 15 maxlength 50");
   }
   else
   {
      Error("TMemStat", "Invalid option");
   }
}

//______________________________________________________________________________
TMemStat::~TMemStat()
{
   // destructor

   if (fIsActive) {
      TMemStatManager::GetInstance()->Disable();
      TMemStatManager::GetInstance()->Close();
   }

   delete fStackSummary;
   delete fSelectedCodeBitmap;
   delete fSelectedStackBitmap;
}

//______________________________________________________________________________
void TMemStat::AddStamp(const char*stampName)
{
   // Add named stamp to the file

   TMemStatManager::GetInstance()->AddStamps(stampName);
}

//______________________________________________________________________________
void TMemStat::Draw(Option_t * /*option*/)
{
   // Draw the memory statistic
   // call ::Report("?") to see possible options and meaning

   // TODO: fix the draw method. Don't use the ROOT graphics
   /*  if (!gPad) {
        new TCanvas;
        gPad->SetTopMargin(0.2);
        gPad->SetRightMargin(0.3);
        gPad->SetLeftMargin(0.10);
     } else {
        gPad->Clear();
     }

     ProcessOption(option);
     TString opt(option);
     opt.ToLower();
     if (opt.Contains("?"))
        return;

     RefreshSelect();

     if (!opt.Contains("code")) {
        SortStack(fSortStat, fSortStamp);
        fArray = MakeGraphStack(fSortStat, fSortDeep);
     } else {
        SortCode(fSortStat, fSortStamp);
        fArray = MakeGraphCode(fSortStat, fSortDeep);
     }

     MakeStampsText();
     if (gPad) {
        fArray->At(0)->Draw("alp");
        gPad->Update();

        TLegend * legend = new TLegend(0.75, 0.1, 0.99, 0.9, "Memory statistic");
        for (Int_t i = 0;i < fArray->GetEntries();i++) {
           fArray->At(i)->Draw("lp");
           cout << i << '\t' << fArray->At(i)->GetName() << endl;
           legend->AddEntry(fArray->At(i), fArray->At(i)->GetName());
           gPad->Update();
        }
        legend->Draw();
        fArray->AddLast(legend);
        for (Int_t i = 0; i < fArrayGraphics->GetEntries(); i++) {
           TText *ptext = dynamic_cast<TText*>(fArrayGraphics->At(i));
           if (ptext) {
              ptext->SetY(gPad->GetUymax());
              ptext->SetTextAngle(45);
              ptext->SetTextSizePixels(12);
              ptext->SetTextAlign(13);
              ptext->Draw("");
           }
           TLine *pline = dynamic_cast<TLine*>(fArrayGraphics->At(i));
           if (pline) {
              pline->SetY2(gPad->GetUymax());
              pline->SetLineStyle(2);
              pline->Draw("");
           }
        }
     }
     AppendPad();*/
}

//______________________________________________________________________________
void TMemStat::GetFillSelection(Selection_t *_Container, ESelection _Selection) const
{
   // TODO: Comment me

   if ( !_Container || !fManager)
      return;

   transform( fManager->fCodeInfoArray.begin(),
              fManager->fCodeInfoArray.end(),
              inserter(*_Container, _Container->begin()),
              bind2nd(SFillSelection(), _Selection) );
}

//______________________________________________________________________________
TObjArray* TMemStat::GetStampList()
{
   // TODO: Comment me
   if (fStampArray)
      return fStampArray;

   if (!fTreeSys)
      return NULL;

   TObjString str;
   TObjString *pstr = &str;
   fStampArray = new TObjArray;
   fTreeSys->SetBranchAddress("StampName.", &pstr);
   for (Int_t i = 0; i < fTreeSys->GetEntries(); ++i) {
      fTreeSys->GetEntry(i);
      fStampArray->AddLast(str.Clone());
   }
   return fStampArray;
}

//______________________________________________________________________________
void TMemStat::MakeReport(const char * lib, const char *fun, Option_t* option, const char *fileName)
{
   // make report for library

   // reset selection
   SelectCode(NULL, NULL, TMemStat::kOR);
   SelectStack(TMemStat::kOR);
   //
   SelectCode(lib, fun, TMemStat::kAND);
   SelectStack(TMemStat::kAND);
   if (option)
      ProcessOption(option);
   SortCode(fSortStat, fSortStamp);
   SortStack(fSortStat, fSortStamp);

   // Redirecting the output if needed
   if (strlen(fileName) > 0)
      gSystem->RedirectOutput(fileName, "w");

   Report();

   if (strlen(fileName) > 0)
      gSystem->RedirectOutput(0);
}

//______________________________________________________________________________
void TMemStat::MakeHisMemoryStamp(Int_t /*topDiff*/)
{
   //draw histogram of memory usage as function of stamp name
   // NOT IMPLEMENTED YET

   const Int_t entries = fTreeSys->Draw("Mem3", "Mem3>0", "");
   DoubleVector_t diff(entries - 1);
   for (Int_t i = 0; i < entries - 1; ++i) {
      diff[i] = fTreeSys->GetV1()[i+1] - fTreeSys->GetV1()[i];
   }
   IntVector_t indexes(entries - 1);
   TMath::Sort(entries - 1, &diff[0], &indexes[0], kFALSE);
}

//______________________________________________________________________________
void TMemStat::MakeHisMemoryTime()
{
   // Make dump of memory usage versus time

   fTreeSys->Draw("Mem3:StampTime.fSec>>hhh", "", "goff*");
   if (!gROOT->FindObject("hhh"))
      return ;

   TH1* his3 = (TH1*)gROOT->FindObject("hhh")->Clone("Virtual Memory");
   his3->SetDirectory(0);
   delete gROOT->FindObject("hhh");

   fTreeSys->Draw("Mem2:StampTime.fSec>>hhh", "", "goff*");
   if (!gROOT->FindObject("hhh"))
      return ;

   TH1* his2 = (TH1*)gROOT->FindObject("hhh")->Clone("Residual Memory");
   his2->SetDirectory(0);
   delete gROOT->FindObject("hhh");

   fTreeSys->Draw("CurrentStamp.fAllocSize/1000000.:StampTime.fSec>>hhh", "", "goff*");
   if (!gROOT->FindObject("hhh"))
      return ;

   TH1* hism = (TH1*)gROOT->FindObject("hhh")->Clone("Allocated Memory");
   hism->SetDirectory(0);
   delete gROOT->FindObject("hhh");

   his3->GetXaxis()->SetTimeDisplay(1);
   his3->SetMarkerColor(2);
   his2->SetMarkerColor(3);
   hism->SetMarkerColor(4);
   his3->Draw();
   his2->Draw("same");
   hism->Draw("same");
}

//______________________________________________________________________________
void TMemStat::Paint(Option_t * /* option */)
{
   // Paint function
}

//______________________________________________________________________________
void TMemStat::PrintCode(Int_t nentries) const
{
   // Print information about n selected functions
   // If the number of function selected is bigger than number n
   // the only top (sorted accoring some creteria,) n are displayed
   // e.g draw.SortCode(TMemStat::kAllocSize,TMemStat::kCurrent);
   if (fSelectedCodeIndex.empty() || !fManager)
      return;

   UIntVector_t::const_iterator iter = max((fSelectedCodeIndex.end() - nentries), fSelectedCodeIndex.begin());
   UIntVector_t::const_iterator iter_end = fSelectedCodeIndex.end();
   for (; iter != iter_end; ++iter)
      fManager->fCodeInfoArray[*iter].Print();
}

//______________________________________________________________________________
void TMemStat::PrintCodeWithID(UInt_t id) const
{
   // print information for code with ID

   if (!fManager)
      return;
   if (id > fManager->fCodeInfoArray.size())
      return;
   fManager->fCodeInfoArray[id].Print();
}

//______________________________________________________________________________
void TMemStat::PrintStack(Int_t nentries, UInt_t deep) const
{
   // Print information about n selected stack traces
   // If the number of function selected is bigger than number n
   // the only top (sorted according some criteria) n are displayed
   // e.g draw.SortCode(TMemStat::kAllocSize,TMemStat::kCurrent);
   if (fSelectedStackIndex.empty())
      return;

   UIntVector_t::const_iterator iter = max((fSelectedStackIndex.end() - nentries), fSelectedStackIndex.begin());
   UIntVector_t::const_iterator iter_end = fSelectedStackIndex.end();
   for (; iter != iter_end; ++iter)
      PrintStackWithID(*iter, deep);

   cout << "Summary for selected:" << endl;
   ios::fmtflags old_flags(cout.flags(ios::left));
   fStackSummary->Print();
   cout.flags(old_flags);
}


//______________________________________________________________________________
void TMemStat::PrintStackWithID(UInt_t _id, UInt_t _deep) const
{
   // print stack information for code with ID
   // NOTE: if _deep is 0, then we use fStackDeep
   if (!fManager)
      return;

   _deep = !_deep ? fStackDeep : _deep;

   const TMemStatStackInfo &infoStack = fManager->fStackVector[_id];
   cout << infoStack << endl;

   ios::fmtflags old_flags(cout.flags(ios::left));
   for (UInt_t icode = 0, counter = 0; icode < infoStack.fSize; ++icode) {
      const TMemStatCodeInfo &infoCode(fManager->fCodeInfoArray[infoStack.fSymbolIndexes[icode]]);
      if (!EnabledCode(infoCode))
         continue;
      cout
      << setw(5) << icode
      << infoCode << endl;
      ++counter;
      if (counter >= _deep)
         break;
   }
   cout.flags(old_flags);
}

//______________________________________________________________________________
void TMemStat::Report(Option_t* option)
{
   // Report function
   // Supported options:
   //
   // order     : 0 - increasing 1 - decreasing
   // sortstat  : 0 - TotalAllocCount 1 -  TotalAlocSize  2 - AllocCount 3 - AllocSize
   // sortstamp : 0 - Current 1 -  MaxSize  2 - MaxCount
   // sortdeep  : (0-inf) number of info to print
   // stackdeep : (0-inf) deepness of stack
   // Example   : order 0 sortstat 3 sortstamp 0 sortdeep 10 stackdeep 5 maxlength 50

   ProcessOption(option);

   TString opt(option);
   opt.ToLower();
   if (opt.Contains("?"))
      return;

   RefreshSelect();

   if (!(opt.Contains("code"))) {
      SortStack(fSortStat, fSortStamp);
      PrintStack(fSortDeep, fStackDeep);
   } else {
      SortCode(fSortStat, fSortStamp);
      PrintCode(fSortDeep);
   }
}

//______________________________________________________________________________
void TMemStat::ResetSelection()
{
   // reset all selections

   fSelectedCodeIndex.clear();
   fSelectedStackIndex.clear();

   delete fSelectedCodeBitmap;
   fSelectedCodeBitmap = NULL;
   delete fSelectedStackBitmap;
   fSelectedStackBitmap = NULL;
   delete fStackSummary;
   fStackSummary = NULL;
}

//______________________________________________________________________________
void TMemStat::SetAutoStamp(Int_t autoStampSize, Int_t autoStampAlloc)
{
   // Change default values of the auto stamping
   //   autoStampSize  [in] - size of invoking STAMPs
   //   autoStampAlloc [in] - a number of allocations

   if (autoStampSize > 0)
      TMemStatManager::GetInstance()->SetAutoStamp(autoStampSize, autoStampAlloc, 10000);
}

//______________________________________________________________________________
void TMemStat::SetCurrentStamp(const char *stampName)
{
   // Getvalues for iven stamp

   GetStampList();

   const Int_t entry = find_string(*fStampArray, stampName);
   GetMemStat(0, entry);
}

//______________________________________________________________________________
void TMemStat::SetCurrentStamp(const TObjString &stampName)
{
   // TODO: Comment me
   SetCurrentStamp(stampName.GetString());
}

//______________________________________________________________________________
void TMemStat::SelectCode(const char *contlib, const char *contfunction, OperType oType)
{
   // select code with given mask
   // contlib       - select only code containing contlib in library path
   // contfunction  - select only code with function name containing contfunction
   // oType         - logical operation - AND and Or is supported
   // By default all code is enabled

   if (!fManager) {
      Error("SelectCode", "MemStat Manager is the NULL object.");
      return;
   }

   const size_t entries = fManager->fCodeInfoArray.size();

   fSelectedCodeIndex.clear();

   if (!fSelectedCodeBitmap) {
      fSelectedCodeBitmap = new TBits(entries);
      for (UInt_t i = 0; i < entries; ++i)
         fSelectedCodeBitmap->SetBitNumber(i, kFALSE);
   }

   switch (oType) {
   case kOR:
      for (UInt_t i = 0; i < entries; ++i) {
         if (fSelectedCodeBitmap->TestBitNumber(i))
            continue;
         const TMemStatCodeInfo &info = fManager->fCodeInfoArray[i];
         if (contlib && (!(info.fLib.Contains(contlib))))
            continue;
         if (contfunction && (!(info.fFunction.Contains(contfunction))))
            continue;
         if (info.fFunction.Contains("TObject::operator new"))
            continue;
         fSelectedCodeBitmap->SetBitNumber(i);
      }
      break;
   case kAND:
      for (UInt_t i = 0; i < entries; i++) {
         if (!(fSelectedCodeBitmap->TestBitNumber(i)))
            continue;
         const TMemStatCodeInfo&info = fManager->fCodeInfoArray[i];
         fSelectedCodeBitmap->SetBitNumber(i, kFALSE);
         if (contlib && (!(info.fLib.Contains(contlib))))
            continue;
         if (contfunction && (!(info.fFunction.Contains(contfunction))))
            continue;
         if (info.fFunction.Contains("TObject::operator new"))
            continue;
         fSelectedCodeBitmap->SetBitNumber(i, kTRUE);
      }
      break;
   case kNOT:
      break;
   }

   MakeCodeArray();
}

//______________________________________________________________________________
void TMemStat::SelectStack(OperType oType)
{
   // select stack containing the selected code
   // oType - And and OR is supported (AND, OR in respect with previous selection)

   if (!fSelectedCodeBitmap || !fManager)
      return;

   const size_t entries = fManager->fStackVector.size();

   fSelectedStackIndex.clear();

   if (!fSelectedStackBitmap) {
      fSelectedStackBitmap = new TBits(entries);
      for (UInt_t i = 0; i < entries; ++i)
         fSelectedStackBitmap->SetBitNumber(i, kFALSE);
   }

   switch (oType) {
   case kOR:
      for (UInt_t i = 0; i < entries; ++i) {
         if (fSelectedStackBitmap->TestBitNumber(i))
            continue;
         const TMemStatStackInfo &info = fManager->fStackVector[i];
         for (UInt_t icode = 0; icode < info.fSize; ++icode) {
            if (fSelectedCodeBitmap->TestBitNumber(info.fSymbolIndexes[icode])) {
               fSelectedStackBitmap->SetBitNumber(i, kTRUE);
            }
         }
      }
      break;
   case kAND:
      for (UInt_t i = 0; i < entries; ++i) {
         if (!(fSelectedStackBitmap->TestBitNumber(i)))
            continue;
         const TMemStatStackInfo &info = fManager->fStackVector[i];
         fSelectedStackBitmap->SetBitNumber(i, kFALSE);
         for (UInt_t icode = 0; icode < info.fSize; ++icode) {
            if (fSelectedCodeBitmap->TestBitNumber(info.fSymbolIndexes[icode])) {
               fSelectedStackBitmap->SetBitNumber(i, kTRUE);
            }
         }
      }
      break;
   case kNOT:
      break;
   }

   MakeStackArray();
}

//______________________________________________________________________________
void TMemStat::SortCode(StatType sortType, StampType stampType)
{
   // sort code according statistical criteria
   // sortType
   // stampType

   if (fSelectedCodeIndex.empty() || !fManager)
      return;

   const Int_t size = fSelectedCodeIndex.size();
   Long64Vector_t values(size);
   TArrayI indexes(size);

   const size_t entries = fManager->fCodeInfoArray.size();
   Int_t iselected = 0;
   for (UInt_t icode = 0; icode < entries; ++icode) {
      if (!(fSelectedCodeBitmap->TestBitNumber(icode)))
         continue;
      TMemStatInfoStamp * info = 0;
      switch (stampType) {
      case kCurrent:
         info = &(fManager->fCodeInfoArray[icode].fCurrentStamp);
         break;
      case kMaxSize:
         info = &(fManager->fCodeInfoArray[icode].fMaxStampSize);
         break;
      case kMaxCount:
         info = &(fManager->fCodeInfoArray[icode].fMaxStamp);
         break;
      }

      if (!info)
         break;

      indexes[iselected] = icode;

      switch (sortType) {
      case kTotalAllocCount:
         values[iselected] = info->fTotalAllocCount;
         break;
      case kAllocCount:
         values[iselected] = info->fAllocCount;
         break;
      case kTotalAllocSize:
         values[iselected] = info->fTotalAllocSize;
         break;
      case kAllocSize:
         values[iselected] = info->fAllocSize;
         break;
      case kUndef:
         break;
      }

      ++iselected;
   }

   TArrayI sortIndexes(size);
   TMath::Sort(iselected, &values[0], &sortIndexes[0], fOrder);

   fSelectedCodeIndex.clear();
   fSelectedCodeIndex.reserve(iselected);
   for (Int_t i = 0; i < iselected; ++i)
      fSelectedCodeIndex.push_back(indexes[sortIndexes[i]]);
}

//______________________________________________________________________________
void TMemStat::SortStack(StatType sortType, StampType stampType)
{
   // sort code according statistical criteria
   // sortType
   // stampType

   if (!fSelectedCodeBitmap || !fManager)
      return;

   const size_t entries = fManager->fStackVector.size();
   Long64Vector_t values(entries);
   TArrayI indexes(entries);

   UInt_t iselected = 0;
   for (UInt_t istack = 0; istack < entries; ++istack) {
      if (!(fSelectedStackBitmap->TestBitNumber(istack)))
         continue;
      TMemStatInfoStamp * info(NULL);
      switch (stampType) {
      case kCurrent:
         info = &(fManager->fStackVector[istack].fCurrentStamp);
         break;
      case kMaxSize:
         info = &(fManager->fStackVector[istack].fMaxStampSize);
         break;
      case kMaxCount:
         info = &(fManager->fStackVector[istack].fMaxStamp);
         break;
      }

      indexes[iselected] = istack;

      switch (sortType) {
      case kTotalAllocCount:
         values[iselected] = info->fTotalAllocCount;
         break;
      case kAllocCount:
         values[iselected] = info->fAllocCount;
         break;
      case kTotalAllocSize:
         values[iselected] = info->fTotalAllocSize;
         break;
      case kAllocSize:
         values[iselected] = info->fAllocSize;
         break;
      case kUndef:
         break;
      }
      if (values[iselected] == 0) continue;
      ++iselected;
   }
   TArrayI  sortIndexes(entries);
   TMath::Sort(static_cast<Int_t>(iselected), &values[0], &sortIndexes[0], fOrder);
   const Int_t sizeOut = TMath::Min(fSortDeep, iselected);
   fSelectedStackIndex.clear();
   fSelectedStackIndex.reserve(sizeOut);
   if (fOrder) {
      for (Int_t i = 0; i < sizeOut; ++i)
         fSelectedStackIndex.push_back(indexes[sortIndexes[i]]);
   } else {
      const Int_t first = (iselected < fSortDeep) ? 0 : iselected - fSortDeep;
      for (UInt_t i = first; i < (first + fSortDeep) && i < iselected; ++i) {
         const UInt_t indexS = sortIndexes[i];
         if (indexS >= entries) {
            cerr << "Error 0 \n";
            continue;
         }
         if (static_cast<size_t>(indexes[indexS]) >= entries) {
            cerr << "Error 1 \n";
            continue;
         }
         const Long64_t value = values[indexS];
         if (0 == value) {
            cerr << "Error 2\n";
            continue;
         }
         fSelectedStackIndex.push_back(indexes[indexS]);
      }
   }
}

//______________________________________________________________________________
Int_t TMemStat::DistancetoPrimitive(Int_t /*px*/, Int_t /*py*/)
{
   // Return distance of the mouse to the TMemStat object

   // TODO: Why we need this method here???
   /*  const Int_t kMinDist = 10;
     if (!fArray)
        return -1;

     const Int_t big = 9999;
     const Int_t kBoundary = 6;
     Int_t puxmin = gPad->XtoAbsPixel(gPad->GetUxmin());
     Int_t puymin = gPad->YtoAbsPixel(gPad->GetUymin());
     Int_t puxmax = gPad->XtoAbsPixel(gPad->GetUxmax());
     Int_t puymax = gPad->YtoAbsPixel(gPad->GetUymax());

     // return if point is not in the graph area
     if (px <= puxmin + kBoundary)
        return big;
     if (py >= puymin - kBoundary)
        return big;
     if (px >= puxmax - kBoundary)
        return big;
     if (py <= puymax + kBoundary)
        return big;

     fSelected = -1;
     Int_t mindist = 9999;
     for (Int_t i = 0; i < fArray->GetSize(); ++i) {
        if (!fArray->At(i))
           continue;
        const Int_t dist = fArray->At(i)->DistancetoPrimitive(px, py);
        if (dist < mindist) {
           mindist = dist;
           fSelected = i;
        }
     }
     if (mindist > kMinDist)
        fSelected = -1;*/
   return -1;
}

//______________________________________________________________________________
Bool_t TMemStat::GetMemStat(const char * fname, Int_t entry)
{
   // Get memstat from tree

   if (fname != 0) {
      fFile.reset(TFile::Open(fname));
      if (!fFile.get() || fFile->IsZombie())
         return kFALSE;

      fTree = dynamic_cast<TTree*>(fFile->Get("MemStat"));
      if (!fTree)
         return kFALSE;

      fTreeSys = dynamic_cast<TTree*>(fFile->Get("MemSys"));
      if (!fTreeSys)
         return kFALSE;
   }

   TMemStatManager *man(NULL);
   // TODO: needs to be investigated.
   // There was a crash, happens when user reselect stamps list after TMemStat Draw has been called.
   // The crash (SEGFAULT) happens in fTree->GetEntry(entry) in access of its buffer.
   // ResetBranchAddresses helped, but it is not clear whether this fix correct or not.
   fTree->ResetBranchAddresses();
   fTree->SetBranchAddress("Manager", &man);

   if ( (entry < 0) || (entry >= fTree->GetEntries()) )
      entry = fTree->GetEntries() - 1;

   fTree->GetEntry(entry);
   fManager = man;
   return kTRUE;
}

//______________________________________________________________________________
Bool_t TMemStat::EnabledCode(const TMemStatCodeInfo &info) const
{
   // Private function
   // disable printing of the predefined code sequence
   if (info.fLib.Contains("libMemStat.so"))
      return kFALSE;
   if (info.fFunction.Contains("operator new"))
      return kFALSE;
   if (info.fFunction.Contains("TMethodCall::Execute"))
      return kFALSE;
   if (info.fFunction.Contains("Cint::G__CallFunc::Exec"))
      return kFALSE;
   if (info.fFunction.Contains("Cint::G__ExceptionWrapper"))
      return kFALSE;
   if (info.fFunction.Sizeof() <= 1)
      return kFALSE;

   for (Int_t i = 0; i < fDisablePrintLib.GetEntries(); ++i) {
      TObjString * str = (TObjString*)fDisablePrintLib.At(i);
      if (str && info.fLib.Contains(str->String().Data()))
         return kFALSE;
   }

   for (Int_t i = 0; i < fDisablePrintCode.GetEntries(); ++i) {
      TObjString * str = (TObjString*)fDisablePrintCode.At(i);
      if (str && info.fFunction.Contains(str->String().Data()))
         return kFALSE;
   }

   return kTRUE;
}

//______________________________________________________________________________
void TMemStat::ExecuteEvent(Int_t /*event*/, Int_t /* px*/, Int_t /*py*/)
{
   // function called when clicking with the mouse on a TMemStat object

   // TODO: this method needs to be revised
   /* switch (event) {
    case kButton1Down:
       if (fArray && fSelected >= 0) {
          const Int_t uid = fArrayIndexes[fSelected];
          cout << endl;
          (uid >= 0) ? PrintStackWithID(uid) : PrintCodeWithID(-uid);
       }
       break;
    case kMouseMotion:
       break;
    case kButton1Motion:
       break;
    case kButton1Up:
       break;
    }*/
}

//______________________________________________________________________________
void TMemStat::MakeCodeArray()
{
   //   PRIVATE: make code index accoring tbit mask

   if (!fManager)
      return;

   Int_t nselected = 0;
   size_t csize = fManager->fCodeInfoArray.size();

   for (UInt_t i = 0; i < csize; ++i)
      if (fSelectedCodeBitmap->TestBitNumber(i))
         ++nselected;

   fSelectedCodeIndex.clear();
   fSelectedCodeIndex.reserve(nselected);
   for (UInt_t i = 0; i < csize; ++i) {
      if (fSelectedCodeBitmap->TestBitNumber(i))
         fSelectedCodeIndex.push_back(i);
   }
}

//______________________________________________________________________________
void TMemStat::MakeStackArray()
{
   //   PRIVATE: make code index according tbit mask

   if (!fManager)
      return;

   delete fStackSummary;
   fStackSummary = new TMemStatInfoStamp();

   fSelectedStackIndex.clear();

   const size_t csize = fManager->fStackVector.size();
   for (size_t i = 0; i < csize; ++i) {
      if (fSelectedStackBitmap->TestBitNumber(i)) {
         fSelectedStackIndex.push_back(i);
         const TMemStatStackInfo &info = fManager->fStackVector[i];
         fStackSummary->fTotalAllocCount += info.fCurrentStamp.fTotalAllocCount;
         fStackSummary->fTotalAllocSize += info.fCurrentStamp.fTotalAllocSize;
         fStackSummary->fAllocCount += info.fCurrentStamp.fAllocCount;
         fStackSummary->fAllocSize += info.fCurrentStamp.fAllocSize;
      }
   }
}



//______________________________________________________________________________
TObjArray *TMemStat::MakeGraphCode(StatType statType, Int_t nentries)
{
   // make array of graphs

   if (fArray) {
      fArray->Delete();
      delete fArray;
   }
   fArray  = new TObjArray(nentries);

   fArrayIndexes.clear();
   fArrayIndexes.resize(nentries);

   Int_t count = 0;
   Double_t xmin = 0, xmax = 0, ymin = 0, ymax = 0;
   Int_t first = TMath::Max(static_cast<Int_t>(fSelectedCodeIndex.size()) - nentries, 0);
   Double_t cxmax, cymax;
   for (Int_t i = fSelectedCodeIndex.size() - 1; i > first; --i) {
      TGraph * gr = MakeGraph(statType, fSelectedCodeIndex[i], TMemStatInfoStamp::kCode, cxmax, cymax);
      if (!gr)
         continue;
      TMemStatCodeInfo  &cinfo =  fManager->fCodeInfoArray[fSelectedCodeIndex[i]];
      if (cinfo.fFunction.Length() > 0) {
         TString str(cinfo.fFunction);
         if ((UInt_t)(str.Length()) > fMaxStringLength)
            str.Resize(fMaxStringLength);
         gr->SetName(str);
      }
      ++count;
      gr->SetLineColor(count % 5 + 1);

      fArrayIndexes[fArray->GetEntries()] = -fSelectedCodeIndex[i];
      fArray->AddLast(gr);
      if (xmin == xmax) {
         xmin = gr->GetXaxis()->GetXmin();
         xmax = cxmax;
         ymin = gr->GetYaxis()->GetXmin();
         ymax = cymax;
      } else {
         xmin = min(xmin, gr->GetXaxis()->GetXmin());
         xmax = max(xmax, cxmax);
         ymin = min(ymin, gr->GetYaxis()->GetXmin());
         ymax = max(ymax, cymax);
      }
   }
   for (Int_t i = 0;i < fArray->GetEntries(); ++i) {
      TGraph * gr = (TGraph*)fArray->At(i);
      gr->GetXaxis()->SetLimits(xmin, xmax);
      gr->GetYaxis()->SetLimits(ymin, ymax);
   }
   return fArray;
}

//______________________________________________________________________________
TObjArray *TMemStat::MakeGraphStack(StatType statType, Int_t nentries)
{
   // make array of graphs

   if (fArray) {
      fArray->Delete();
      delete fArray;
   }
   fArray = new TObjArray(nentries);

   fArrayIndexes.clear();
   fArrayIndexes.resize(nentries);

   Int_t count = 0;
   Double_t xmin = 0, xmax = 0, ymin = 0, ymax = 0;
   const Int_t first = TMath::Max(static_cast<int>(fSelectedStackIndex.size()) - nentries, 0);
   Double_t cxmax(0);
   Double_t cymax(0);
   for (Int_t i = fSelectedStackIndex.size() - 1; i > first; --i) {
      TGraph * gr = MakeGraph(statType, fSelectedStackIndex[i], TMemStatInfoStamp::kStack, cxmax, cymax);
      if (!gr)
         continue;
      TMemStatStackInfo &infoStack = fManager->fStackVector[(fSelectedStackIndex[i])];
      for (UInt_t icode = 0; icode < infoStack.fSize; icode++) {
         TMemStatCodeInfo &infoCode = fManager->fCodeInfoArray[infoStack.fSymbolIndexes[icode]];
         if (EnabledCode(infoCode)) {
            if (infoCode.fFunction) {
               TString str(infoCode.fFunction);
               if ((UInt_t)(str.Length()) > fMaxStringLength) str.Resize(fMaxStringLength);
               gr->SetName(str);
               gr->SetUniqueID(fSelectedStackIndex[i]);
            }
            break;
         }
      }
      ++count;
      gr->SetLineColor(count % 5 + 1);
      gr->SetMarkerColor(count % 5 + 1);
      gr->SetMarkerStyle(20 + count % 5);
      gr->SetMarkerSize(0.15);
      fArrayIndexes[fArray->GetEntries()] = fSelectedStackIndex[i];
      fArray->AddLast(gr);
      if (xmin == xmax) {
         xmin = gr->GetXaxis()->GetXmin();
         xmax = cxmax;
         ymin = gr->GetYaxis()->GetXmin();
         ymax = cymax;
      } else {
         xmin = min(xmin, gr->GetXaxis()->GetXmin());
         xmax = max(xmax, cxmax);
         ymin = min(ymin, gr->GetYaxis()->GetXmin());
         ymax = max(ymax, cymax);
      }
   }

   for (Int_t i = 0; i < fArray->GetEntries(); ++i) {
      TGraph * gr = (TGraph*)fArray->At(i);
      gr->GetXaxis()->SetLimits(xmin, xmax);
      gr->GetYaxis()->SetLimits(ymin, ymax);
   }

   return fArray;
}

//______________________________________________________________________________
TGraph *TMemStat::MakeGraph(StatType statType, Int_t id, Int_t type, Double_t &xmax, Double_t &ymax)
{
   // Make graph

   if (!fTree)
      return 0;

   string sWhat;
   string sWhatName;
   switch (statType) {
   case kTotalAllocCount:
      sWhat = "fStampVector.fTotalAllocCount:fStampVector.fStampNumber";
      sWhatName = "TotalAllocCount";
      break;
   case kAllocCount:
      sWhat = "fStampVector.fAllocCount:fStampVector.fStampNumber";
      sWhatName = "AllocCount";
      break;
   case kTotalAllocSize:
      sWhat = "fStampVector.fTotalAllocSize/1000000.:fStampVector.fStampNumber";
      sWhatName = "TotalAllocSize (MBy)";
      break;
   case kAllocSize:
      sWhat = "fStampVector.fAllocSize/1000000.:fStampVector.fStampNumber";
      sWhatName = "AllocSize (MBy)";
      break;
   case kUndef:
      // TODO: check this case; in original code it wasn't handled
      break;
   }
   ostringstream ssWhere;
   ssWhere << "fStampVector.fID==" << id << "&&fStampVector.fStampType==" << type;

   const Int_t entries = fTree->Draw(sWhat.c_str(), ssWhere.str().c_str(), "goff");
   if (entries <= 0)
      return 0;

   const Int_t maxStamp = fManager->fStampNumber;

   Float_t *x = new Float_t[maxStamp];
   Float_t *y = new Float_t[maxStamp];
   xmax = 0;
   ymax = 0;
   Float_t last = 0;
   for (Int_t i = 0, counter = 0; i < maxStamp; ++i) {
      x[i] = i;
      y[i] = last;
      if (y[i] > ymax) ymax = y[i];
      if (x[i] > xmax) xmax = x[i];
      if (counter >= entries)
         continue;
      if (fTree->GetV2()[counter] > i) {
         y[i] = last;
      } else {
         y[i] = fTree->GetV1()[counter];
         last = y[i];
         ++counter;
      }
   }
   TGraph * graph  = new TGraph(maxStamp, x, y);
   graph->GetXaxis()->SetTitle("StampNumber");
   graph->GetYaxis()->SetTitle(sWhatName.c_str());
   return graph;
}

//______________________________________________________________________________
void TMemStat::MakeStampsText()
{
   // Make a text description of the stamps
   // create a array of TText objects

   // TODO: see TMemStat::Draw
   /*if (!fArrayGraphics)
       fArrayGraphics = new TObjArray();

    const Int_t nentries = fTree->GetEntries();
    Int_t stampNumber(0);
    TObjString *pnameStamp(NULL);
    TTimeStamp *ptimeStamp(NULL);
    fTree->SetBranchAddress("StampTime.", &ptimeStamp);
    fTree->SetBranchAddress("StampName.", &pnameStamp);
    fTree->SetBranchAddress("StampNumber", &stampNumber);

    for (Int_t i = 0; i < nentries; ++i) {
       fTree->GetBranch("StampTime.")->GetEntry(i);
       fTree->GetBranch("StampName.")->GetEntry(i);
       fTree->GetBranch("StampNumber")->GetEntry(i);
       char chname[1000];
       if (pnameStamp->GetString().Contains("autoStamp")) {
          sprintf(chname, " ");
       } else {
          sprintf(chname, "%s  %d", pnameStamp->GetString().Data(), ptimeStamp->GetTime());
       }
       TText *ptext = new TText(stampNumber, 0, chname);
       fArrayGraphics->AddLast(ptext);
       TLine * pline = new TLine(stampNumber, 0, stampNumber, 1);
       fArrayGraphics->AddLast(pline);
    }*/
}

//______________________________________________________________________________
void TMemStat::ProcessOption(Option_t *option)
{
   // PRIVATE function
   // process user option string for printing

   TString str(option);
   TString delim(" ");
   TObjArray *tokens = str.Tokenize(delim);
   for (Int_t i = 0; i < tokens->GetEntriesFast() - 1; ++i) {
      TObjString *strTok = (TObjString*)tokens->At(i);
      TObjString *strNum = (i < tokens->GetEntriesFast()) ? (TObjString*)tokens->At(i + 1) : 0;

      if (strNum && strNum->String().IsDigit()) {
         if (strTok->String().Contains("sortstat")) {
            Int_t val = strNum->String().Atoi();
            if (val > 3) {
               Error("SetOption", Form("Invalid value for sortstat %d", val));
               val = 3;
            }
            fSortStat = (TMemStat::StatType)val;
         }
         if (strTok->String().Contains("sortstamp")) {
            Int_t val = strNum->String().Atoi();
            if (val > 2) {
               Error("SetOption", Form("Invalid value for sortstamp %d", val));
               val = 0;
            }
            fSortStamp = (TMemStat::StampType)val;
         }

         if (strTok->String().Contains("order")) {
            Int_t val = strNum->String().Atoi();
            if (val > 1) {
               Error("SetOption", Form("Invalid sorting value", val));
               val = 0;
            }
            fOrder = (val > 0);
         }
         if (strTok->String().Contains("sortdeep")) {
            fSortDeep = strNum->String().Atoi();
         }
         if (strTok->String().Contains("stackdeep")) {
            fStackDeep  = strNum->String().Atoi();
         }
         if (strTok->String().Contains("maxlength")) {
            fMaxStringLength  = strNum->String().Atoi();
         }
      }
   }
   char currentOption[1000];
   sprintf(currentOption, "order %d sortstat %d sortstamp %d sortdeep %d stackdeep %d maxlength %d",
           fOrder, fSortStat, fSortStamp, fSortDeep, fStackDeep, fMaxStringLength);
   fOption = currentOption;
   if (str.Contains("?")) {
      printf("Options   : %s\n", fOption.Data());
      printf("order     : 0 - increasing 1 - decreasing\n");
      printf("sortstat  : 0 - TotalAllocCount 1 -  TotalAlocSize  2 - AllocCount 3 - AllocSize\n");
      printf("sortstamp : 0 - Current 1 -  MaxSize  2 - MaxCount\n");
      printf("sortdeep  : (0-inf) number of info to print\n");
      printf("stackdeep : (0-inf) deepnes of stack\n");
      printf("maxlength : (0-inf) maximal length of function (truncation after maxlength)");
   }

   delete tokens;
}

//______________________________________________________________________________
void TMemStat::RefreshSelect()
{
   // TODO: Comment me
   if (fSelectedCodeIndex.empty())
      SelectCode(NULL, NULL, TMemStat::kOR);

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