// @(#)root/html:$Id: 7ff9b72609794c66acf6b369c4eeddfbfc63cf55 $
// Author: Axel Naumann 2007-01-09

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

#include "TDocOutput.h"

#include "Riostream.h"
#include "TClassDocOutput.h"
#include "TClassEdit.h"
#include "TDataMember.h"
#include "TDataType.h"
#include "TDocInfo.h"
#include "TDocParser.h"
#include "TEnv.h"
#include "TGlobal.h"
#include "THtml.h"
#include "TInterpreter.h"
#include "TMethod.h"
#include "TPRegexp.h"
#include "TROOT.h"
#include "TSystem.h"
#include "TUrl.h"
#include "TVirtualMutex.h"
#include "TVirtualPad.h"
#include "TVirtualViewer3D.h"
#include <vector>
#include <list>
#include <set>
#include <sstream>
#include <stdlib.h>

namespace {

   typedef std::vector<std::string> Words_t;
   typedef Words_t::const_iterator SectionStart_t;

   class TSectionInfo {
   public:
      TSectionInfo(SectionStart_t start, size_t chars, size_t size):
         fStart(start), fChars(chars), fSize(size) {};

         SectionStart_t fStart;
         size_t fChars;
         size_t fSize;
   };
   typedef std::list<TSectionInfo> SectionStarts_t;

   static void Sections_BuildIndex(SectionStarts_t& sectionStarts,
      SectionStart_t begin, SectionStart_t end,
      size_t maxPerSection)
   {
      // for each assumed section border, check that previous entry's
      // char[selectionChar] differs, else move section start forward

      SectionStart_t cursor = begin;
      if (sectionStarts.empty() || sectionStarts.back().fStart != cursor)
         sectionStarts.push_back(TSectionInfo(cursor, 1, 0));

      SectionStarts_t::iterator prevSection = sectionStarts.end();
      --prevSection;

      while (cursor != end) {
         size_t numLeft = end - cursor;
         size_t assumedNumSections = (numLeft + maxPerSection - 1 ) / maxPerSection;
         size_t step = ((numLeft + assumedNumSections - 1) / assumedNumSections);
         if (!step || step >= numLeft) return;
         cursor += step;
         if (cursor == end) break;

         SectionStart_t addWhichOne = prevSection->fStart;

         size_t selectionChar=1;
         for (; selectionChar <= cursor->length() && addWhichOne == prevSection->fStart;
            ++selectionChar) {
            SectionStart_t checkPrev = cursor;
            while (--checkPrev != prevSection->fStart
               && !strncasecmp(checkPrev->c_str(), cursor->c_str(), selectionChar)) { }

            SectionStart_t checkNext = cursor;
            while (++checkNext != end
               && !strncasecmp(checkNext->c_str(), cursor->c_str(), selectionChar)) { }

            // if the previous matching one is closer but not previous section start, take it!
            if (checkPrev != prevSection->fStart) {
               if ((cursor - checkPrev) <= (checkNext - cursor))
                  addWhichOne = ++checkPrev;
               else if (checkNext != end
                  && (size_t)(checkNext - cursor) < maxPerSection) {
                  addWhichOne = checkNext;
               }
            }
         }
         if (addWhichOne == prevSection->fStart)
            addWhichOne = cursor;

         selectionChar = 1;
         while (selectionChar <= prevSection->fStart->length()
            && selectionChar <= addWhichOne->length()
            && !strncasecmp(prevSection->fStart->c_str(), addWhichOne->c_str(), selectionChar))
            ++selectionChar;

         sectionStarts.push_back(TSectionInfo(addWhichOne, selectionChar, 0));
         cursor = addWhichOne;
         ++prevSection;
      } // while cursor != end
   }

   static void Sections_SetSize(SectionStarts_t& sectionStarts, const Words_t &words)
   {
      // Update the length of the sections
      for (SectionStarts_t::iterator iSectionStart = sectionStarts.begin();
         iSectionStart != sectionStarts.end(); ++iSectionStart) {
         SectionStarts_t::iterator next = iSectionStart;
         ++next;
         if (next == sectionStarts.end()) {
            iSectionStart->fSize = (words.end() - iSectionStart->fStart);
            break;
         }
         iSectionStart->fSize = (next->fStart - iSectionStart->fStart);
      }
   }

   static void Sections_PostMerge(SectionStarts_t& sectionStarts, const size_t maxPerSection)
   {
      // Merge sections that ended up being too small, up to maxPerSection entries
      for (SectionStarts_t::iterator iSectionStart = sectionStarts.begin();
         iSectionStart != sectionStarts.end();) {
         SectionStarts_t::iterator iNextSectionStart = iSectionStart;
         ++iNextSectionStart;
         if (iNextSectionStart == sectionStarts.end()) break;
         if (iNextSectionStart->fSize + iSectionStart->fSize < maxPerSection) {
            iSectionStart->fSize += iNextSectionStart->fSize;
            sectionStarts.erase(iNextSectionStart);
         } else ++iSectionStart;
      }
   }

   static void GetIndexChars(const Words_t& words, UInt_t numSectionsIn,
      std::vector<std::string> &sectionMarkersOut)
   {
      // Given a list of words (class names, in this case), this function builds an
      // optimal set of about numSectionIn sections (even if almost all words start
      // with a "T"...), and returns the significant characters for each section start
      // in sectionMarkersOut.

      const size_t maxPerSection = (words.size() + numSectionsIn - 1)/ numSectionsIn;
      SectionStarts_t sectionStarts;
      Sections_BuildIndex(sectionStarts, words.begin(), words.end(), maxPerSection);
      Sections_SetSize(sectionStarts, words);
      Sections_PostMerge(sectionStarts, maxPerSection);

      // convert to index markers
      sectionMarkersOut.clear();
      sectionMarkersOut.resize(sectionStarts.size());
      size_t idx = 0;
      for (SectionStarts_t::iterator iSectionStart = sectionStarts.begin();
         iSectionStart != sectionStarts.end(); ++iSectionStart)
         sectionMarkersOut[idx++] =
            iSectionStart->fStart->substr(0, iSectionStart->fChars);
   }

   static void GetIndexChars(const std::list<std::string>& wordsIn, UInt_t numSectionsIn,
      std::vector<std::string> &sectionMarkersOut)
   {
      // initialize word vector
      Words_t words(wordsIn.size());
      size_t idx = 0;
      for (std::list<std::string>::const_iterator iWord = wordsIn.begin(); iWord != wordsIn.end(); ++iWord)
         words[idx++] = *iWord;
      GetIndexChars(words, numSectionsIn, sectionMarkersOut);
   }

}

extern "C" { // std::qsort on solaris wants the sorter to be extern "C"

   //______________________________________________________________________________
   static int CaseInsensitiveSort(const void *name1, const void *name2)
   {
   // Friend function for sorting strings, case insensitive
   //
   //
   // Input: name1 - pointer to the first string
   //        name2 - pointer to the second string
   //
   //  NOTE: This function compares its arguments and returns an integer less
   //        than, equal to, or greater than zero, depending on whether name1
   //        is lexicographically less than, equal to, or greater than name2,
   //        but characters are forced to lower-case prior to comparison.
   //
   //

      return (strcasecmp(*((char **) name1), *((char **) name2)));
   }
}

namespace {

   // std::list::sort(with_stricmp_predicate) doesn't work with Solaris CC...
   static void sort_strlist_stricmp(std::vector<std::string>& l)
   {
      // sort strings ignoring case - easier for humans
      struct posList {
         const char* str;
         size_t pos;
      };
      posList* carr = new posList[l.size()];
      size_t idx = 0;
      for (size_t iS = 0, iSE = l.size(); iS < iSE; ++iS) {
         carr[idx].pos = iS;
         carr[idx++].str = l[iS].c_str();
      }
      qsort(&carr[0].str, idx, sizeof(posList), CaseInsensitiveSort);
      std::vector<std::string> lsort(l.size());
      for (size_t iS = 0, iSE = l.size(); iS < iSE; ++iS) {
         lsort[iS].swap(l[carr[iS].pos]);
      }
      delete [] carr;
      l.swap(lsort);
   }

}

//______________________________________________________________________________
//
// THtml generated documentation is written to file by TDocOutput. So far only
// output of HTML is implemented. Customization of the output should be done
// with THtml's interfaces - TDocOutput should not be used nor re-implemented
// directly.
//
// TDocOutput generates the index tables:
// * classes (THtml invokes TClassDocOutput for each),
// * inheritance hierarchy,
// * types and typedefs,
// * libraries,
// * the product index, and
// * the module index (including the links to per-module documentation).
// It invokes AT&T's GraphViz tool (dot) if available; charts benefit a lot
// from it.
//
// TDocOutput also writes all pages' header and footer, which can be customized
// by calling THtml::SetHeader(), THtml::SetFooter().
//______________________________________________________________________________

ClassImp(TDocOutput);

//______________________________________________________________________________
TDocOutput::TDocOutput(THtml& html): fHtml(&html)
{}

//______________________________________________________________________________
TDocOutput::~TDocOutput()
{}

//______________________________________________________________________________
void TDocOutput::AddLink(TSubString& str, TString& link, const char* comment)
{
   // Add a link around str, with title comment.
   // Update str so it surrounds the link.

   // prepend "./" to allow callers to replace a different relative directory
   if (ReferenceIsRelative(link) && !link.BeginsWith("./"))
      link.Prepend("./");
   link.Prepend("<a href=\"");
   link += "\"";
   if (comment && strlen(comment)) {
      link += " title=\"";
      TString description(comment);
      ReplaceSpecialChars(description);
      description.ReplaceAll("\"", "&quot;");
      link += description;
      link += "\"";
   }
   link += ">";

   str.String().Insert(str.Start() + str.Length(), "</a>");
   str.String().Insert(str.Start(), link);

   TString &strString = str.String();
   TSubString update = strString(str.Start(), str.Length() + link.Length() + 4);
   str = update;
}

//______________________________________________________________________________
void TDocOutput::AdjustSourcePath(TString& line, const char* relpath /*= "../"*/)
{
   // adjust the path of links for source files, which are in src/, but need
   // to point to relpath (usually "../"). Simply replaces "=\"./" by "=\"../"

   TString replWithRelPath("=\"@!@");
   line.ReplaceAll("=\"../", replWithRelPath + "../" + relpath);
   line.ReplaceAll("=\"./", replWithRelPath + relpath);
   line.ReplaceAll("=\"@!@","=\"");
}

//______________________________________________________________________________
void TDocOutput::Convert(std::istream& in, const char* infilename,
                         const char* outfilename, const char *title,
                         const char *relpath /*= "../"*/, Int_t includeOutput /*=0*/,
                         const char* context /*= ""*/,
                         TGClient* gclient /*= 0*/)
{
   // Convert a text file into a html file.
   // outfilename doesn't have an extension yet; up to us to decide.
   // We generate HTML, so our extension is ".html".
   // See THtml::Convert() for the other parameters.

   TString htmlFilename(outfilename);
   htmlFilename += ".html";

   std::ofstream out(htmlFilename);

   if (!out.good()) {
      Error("Convert", "Can't open file '%s' !", htmlFilename.Data());
      return;
   }

   // write a HTML header
   WriteHtmlHeader(out, title, relpath);

   if (context && context[0])
      out << context << std::endl;
   else if (title && title[0])
      out << "<h1 class=\"convert\">" << title << "</h1>" << std::endl;

   Int_t numReuseCanvases = 0;
   if (includeOutput && !(includeOutput & THtml::kForceOutput)) {
      void* dirHandle = gSystem->OpenDirectory(gSystem->DirName(htmlFilename));
      if (dirHandle) {
         FileStat_t infile_stat;
         if (!gSystem->GetPathInfo(infilename, infile_stat)) {
            // can stat.
            const char* outfile = 0;
            TString firstCanvasFileBase(gSystem->BaseName(outfilename));
            firstCanvasFileBase += "_0.png";
            // first check whether the firstCanvasFile exists:
            Bool_t haveFirstCanvasFile = false;
            while ((outfile = gSystem->GetDirEntry(dirHandle))) {
               if (firstCanvasFileBase == outfile) {
                  haveFirstCanvasFile = true;
                  break;
               }
            }
            gSystem->FreeDirectory(dirHandle);

            FileStat_t outfile_stat;
            TString firstCanvasFile = outfilename;
            firstCanvasFile += "_0.png";
            Int_t maxIdx = -1;
            if (haveFirstCanvasFile && !gSystem->GetPathInfo(firstCanvasFile, outfile_stat)
                && outfile_stat.fMtime > infile_stat.fMtime) {
               // the first canvas file exists and it is newer than the script, so we reuse
               // the canvas files. We need to know how many there are:
               dirHandle = gSystem->OpenDirectory(gSystem->DirName(htmlFilename));
               TString stem(gSystem->BaseName(outfilename));
               stem += "_";
               TString dir(gSystem->DirName(htmlFilename));
               while ((outfile = gSystem->GetDirEntry(dirHandle))) {
                  if (strncmp(outfile, stem, stem.Length()))
                     continue;
                  const char* posext = strrchr(outfile, '.');
                  if (!posext || strcmp(posext, ".png"))
                     continue;

                  // extract the mod time of the PNG file
                  if (gSystem->GetPathInfo(dir + "/" + outfile, outfile_stat))
                     // can't stat!
                     continue;

                  if (outfile_stat.fMtime > infile_stat.fMtime) {
                     ++numReuseCanvases;
                     // The canvas PNG is newer than the script, so
                     // extract the index of the canvas
                     TString idxStr(outfile + stem.Length());
                     idxStr.Remove(idxStr.Length() - 4);
                     Int_t idx = idxStr.Atoi();
                     if (maxIdx < idx)
                        maxIdx = idx;
                  }
               }
               gSystem->FreeDirectory(dirHandle);
               if (maxIdx + 1 != numReuseCanvases)
                  // bad: the number of canvases to reuse noes not correspond to the highest index we saw.
                  // we will need to regenerate evrything.
                  numReuseCanvases = 0;
            }
         } // infile can be stat'ed
      } // can open output directory
   } // canvases wanted

   if (numReuseCanvases)
      Printf("Convert: %s (reusing %d saved canvas%s)", htmlFilename.Data(), numReuseCanvases, (numReuseCanvases > 1 ? "es" : ""));
   else
      Printf("Convert: %s", htmlFilename.Data());

   UInt_t nCanvases = numReuseCanvases;
   if (includeOutput) {
      if (!numReuseCanvases) {
         // need to run the script
         if (includeOutput & THtml::kSeparateProcessOutput) {
            TString baseInFileName = gSystem->BaseName(infilename);
            TPMERegexp reOutFile(baseInFileName + "_[[:digit:]]+\\.png");

            // remove all files matching what saveScriptOutput.C could produce:
            void* outdirH = gSystem->OpenDirectory(gSystem->DirName(outfilename));
            if (outdirH) {
               // the directory exists.
               const char* outdirE = 0;
               while ((outdirE = gSystem->GetDirEntry(outdirH))) {
                  if (reOutFile.Match(outdirE)) {
                     gSystem->Unlink(outdirE);
                  }
               }
               gSystem->FreeDirectory(outdirH);
            }

            gSystem->Exec(TString::Format("ROOT_HIST=0 root.exe -l -q %s $ROOTSYS/etc/html/saveScriptOutput.C\\(\\\"%s\\\",\\\"%s\\\",%d\\)",
                          gROOT->IsBatch() ? "-b" : "",
                          infilename,
                          gSystem->DirName(outfilename),
                          includeOutput & THtml::kCompiledOutput));

            // determine how many output files were created:
            outdirH = gSystem->OpenDirectory(gSystem->DirName(outfilename));
            if (outdirH) {
               // the directory exists.
               const char* outdirE = 0;
               while ((outdirE = gSystem->GetDirEntry(outdirH))) {
                  if (reOutFile.Match(outdirE)) {
                     ++nCanvases;
                  }
               }
               gSystem->FreeDirectory(outdirH);
            }
         } else {
            // run in this ROOT process
            TString pwd(gSystem->pwd());
            gSystem->cd(gSystem->DirName(infilename));

            TList* gClientGetListOfWindows = 0;
            TObject* gClientGetDefaultRoot = 0;
            std::set<TObject*> previousWindows;
            if (gclient) {
               gROOT->ProcessLine(TString::Format("*((TList**)0x%lx) = ((TGClient*)0x%lx)->GetListOfWindows();",
                                                  (ULong_t)&gClientGetListOfWindows, (ULong_t)gclient));
               gROOT->ProcessLine(TString::Format("*((TObject**)0x%lx) = ((TGClient*)0x%lx)->GetDefaultRoot();",
                                                  (ULong_t)&gClientGetDefaultRoot, (ULong_t)gclient));
               TObject* win = 0;
               TIter iWin(gClientGetListOfWindows);
               while((win = iWin())) {
                  TObject* winGetParent = 0;
                  gROOT->ProcessLine(TString::Format("*((TObject**)0x%lx) = ((TGWindow*)0x%lx)->GetParent();",
                                                     (ULong_t)&winGetParent, (ULong_t)win));
                  if (winGetParent == gClientGetDefaultRoot)
                     previousWindows.insert(win);
               }
            } else {
               if (gROOT->GetListOfCanvases()->GetSize())
                  previousWindows.insert(gROOT->GetListOfCanvases()->Last());
            }
            TIter iTimer(gSystem->GetListOfTimers());
            std::set<TObject*> timersBefore;
            TObject* timerOld = 0;
            while ((timerOld = iTimer()))
               timersBefore.insert(timerOld);

            TString cmd(".x ");
            cmd += gSystem->BaseName(infilename);
            if (includeOutput & THtml::kCompiledOutput)
               cmd += "+";
            gInterpreter->SaveContext();
            gInterpreter->SaveGlobalsContext();
            Int_t err;
            gROOT->ProcessLine(cmd, &err);
            gSystem->ProcessEvents();
            gSystem->cd(pwd);

            if (err == TInterpreter::kNoError) {
               if (gclient) {
                  TClass* clRootCanvas = TClass::GetClass("TRootCanvas");
                  TClass* clGMainFrame = TClass::GetClass("TGMainFrame");
                  TObject* win = 0;
                  TIter iWin(gClientGetListOfWindows);
                  while((win = iWin())) {
                     TObject* winGetParent = 0;
                     gROOT->ProcessLine(TString::Format("*((TObject**)0x%lx) = ((TGWindow*)0x%lx)->GetParent();",
                                                        (ULong_t)&winGetParent, (ULong_t)win));
                     Bool_t winIsMapped = kFALSE;
                     if (winGetParent == gClientGetDefaultRoot)
                        gROOT->ProcessLine(TString::Format("*((Bool_t*)0x%lx) = ((TGWindow*)0x%lx)->IsMapped();",
                                                           (ULong_t)&winIsMapped, (ULong_t)win));
                     if (winIsMapped && previousWindows.find(win) == previousWindows.end()
                         && win->InheritsFrom(clGMainFrame)) {
                        gROOT->ProcessLine(TString::Format("((TGWindow*)0x%lx)->MapRaised();", (ULong_t)win));
                        Bool_t isRootCanvas = win->InheritsFrom(clRootCanvas);
                        Bool_t hasEditor = false;
                        if (isRootCanvas) {
                           gROOT->ProcessLine(TString::Format("*((Bool_t*)0x%lx) = ((TRootCanvas*)0x%lx)->HasEditor();",
                                                              (ULong_t)&hasEditor, (ULong_t)win));
                        }
                        if (isRootCanvas && !hasEditor) {
                           TVirtualPad* pad = 0;
                           gROOT->ProcessLine(TString::Format("*((TVirtualPad**)0x%lx) = ((TRootCanvas*)0x%lx)->Canvas();",
                                                              (ULong_t)&pad, (ULong_t)win));
                           if (!pad->HasViewer3D() || pad->GetViewer3D()->InheritsFrom("TViewer3DPad")) {
                              pad->SaveAs(TString::Format("%s_%d.png", outfilename, nCanvases++));
                           }
                        } else
                           gROOT->ProcessLine(TString::Format("((TGWindow*)0x%lx)->SaveAs(\"%s_%d.png\");",
                                                              (ULong_t)win, outfilename, nCanvases++));
                     }
                  }
               } else {
                  // no gClient
                  TVirtualPad* pad = 0;
                  TVirtualPad* last = 0;
                  if (!previousWindows.empty())
                     last = (TVirtualPad*) *previousWindows.begin();
                  TIter iCanvas(gROOT->GetListOfCanvases());
                  while ((pad = (TVirtualPad*) iCanvas())) {
                     if (last) {
                        if (last == pad) last = 0;
                        continue;
                     }
                     pad->SaveAs(TString::Format("%s_%d.png", outfilename, nCanvases++));
                  }
               }
               gInterpreter->Reset();
               gInterpreter->ResetGlobals();
               TIter iTimerRemove(gSystem->GetListOfTimers());
               TTimer* timer = 0;
               while ((timer = (TTimer*) iTimerRemove()))
                  if (timersBefore.find(timer) == timersBefore.end())
                     gSystem->RemoveTimer(timer);
            }
         } // run script in this ROOT process
      }
      out << "<table><tr><td style=\"vertical-align:top;padding-right:2em;\">" << std::endl;
   }
   out << "<div class=\"listing\"><pre class=\"listing\">" << std::endl;

   TDocParser parser(*this);
   parser.Convert(out, in, relpath, (includeOutput) /* determines whether it's code or not */,
                  kFALSE /*interpretDirectives*/);

   out << "</pre></div>" << std::endl;

   WriteLineNumbers(out, parser.GetLineNumber(), gSystem->BaseName(infilename));

   if (includeOutput) {
      out << "</td><td style=\"vertical-align:top;\">" << std::endl;
      out << "<table>" << std::endl;
      for (UInt_t i = 0; i < nCanvases; ++i) {
         TString pngname = TString::Format("%s_%d.png", gSystem->BaseName(outfilename), i);
         out << "<tr><td><a href=\"" << pngname << "\">" << std::endl
             << "<img src=\"" << pngname << "\" id=\"canv" << i << "\" alt=\"thumb\" style=\"border:none;width:22em;\" "
            "onmouseover=\"javascript:canv" << i << ".style.width='auto';\" />" << std::endl
             << "</a></td></tr>" << std::endl;
         }
      out << "</table>" << std::endl;
      out << "</td></tr></table>" << std::endl;
   }

   // write a HTML footer
   WriteHtmlFooter(out, relpath);
}

//______________________________________________________________________________
Bool_t TDocOutput::CopyHtmlFile(const char *sourceName, const char *destName)
{
// Copy file to HTML directory
//
//
//  Input: sourceName - source file name (fully qualified i.e. file system path)
//         destName   - optional destination name, if not
//                      specified it would be the same
//                      as the source file name
//
// Output: TRUE if file is successfully copied, or
//         FALSE if it's not
//
//
//   NOTE: The destination directory is always fHtml->GetOutputDir()
//

   R__LOCKGUARD(GetHtml()->GetMakeClassMutex());

   TString sourceFile(sourceName);

   if (!sourceFile.Length()) {
      Error("Copy", "Can't copy file '%s' to '%s' directory - source file name invalid!", sourceName,
            fHtml->GetOutputDir().Data());
      return kFALSE;
   }

   // destination file name
   TString destFile;
   if (!destName || !*destName)
      destFile = gSystem->BaseName(sourceFile);
   else
      destFile = gSystem->BaseName(destName);

   gSystem->PrependPathName(fHtml->GetOutputDir(), destFile);

   // Get info about a file
   Long64_t size;
   Long_t id, flags, sModtime, dModtime;
   sModtime = 0;
   dModtime = 0;
   if (gSystem->GetPathInfo(sourceFile, &id, &size, &flags, &sModtime)
      || gSystem->GetPathInfo(destFile, &id, &size, &flags, &dModtime)
      || sModtime > dModtime)
      if (gSystem->CopyFile(sourceFile, destFile, kTRUE) < 0) {
         Error("Copy", "Can't copy file '%s' to '%s'!",
               sourceFile.Data(), destFile.Data());
         return kFALSE;
      }

   return kTRUE;
}



//______________________________________________________________________________
void TDocOutput::CreateHierarchy()
{
// Create a hierarchical class list
// The algorithm descends from the base classes and branches into
// all derived classes. Mixing classes are displayed several times.
//
//

   // if (CreateHierarchyDot()) return;

   TString filename("ClassHierarchy.html");
   gSystem->PrependPathName(fHtml->GetOutputDir(), filename);

   // open out file
   std::ofstream out(filename);

   if (!out.good()) {
      Error("CreateHierarchy", "Can't open file '%s' !", filename.Data());
      return;
   }

   Printf(fHtml->GetCounterFormat(), "", fHtml->GetCounter(), filename.Data());

   // write out header
   WriteHtmlHeader(out, "Class Hierarchy");

   WriteTopLinks(out, 0);

   out << "<h1>Class Hierarchy</h1>" << std::endl;


   // loop on all classes
   TClassDocInfo* cdi = 0;
   TIter iClass(fHtml->GetListOfClasses());
   while ((cdi = (TClassDocInfo*)iClass())) {
      if (!cdi->HaveSource())
         continue;

      // get class
      TDictionary *dictPtr = cdi->GetClass();
      TClass *basePtr = dynamic_cast<TClass*>(dictPtr);
      if (basePtr == 0) {
         if (!dictPtr)
            Warning("THtml::CreateHierarchy", "skipping class %s\n", cdi->GetName());
         continue;
      }

      TClassDocOutput cdo(*fHtml, basePtr, 0);
      cdo.CreateClassHierarchy(out, cdi->GetHtmlFileName());
   }

   // write out footer
   WriteHtmlFooter(out);
}

//______________________________________________________________________________
void TDocOutput::CreateClassIndex()
{
// Create index of all classes
//

   // create CSS file, we need it
   fHtml->CreateAuxiliaryFiles();

   TString filename("ClassIndex.html");
   gSystem->PrependPathName(fHtml->GetOutputDir(), filename);

   // open indexFile file
   std::ofstream indexFile(filename.Data());

   if (!indexFile.good()) {
      Error("CreateClassIndex", "Can't open file '%s' !", filename.Data());
      return;
   }

   Printf(fHtml->GetCounterFormat(), "", fHtml->GetCounter(), filename.Data());

   // write indexFile header
   WriteHtmlHeader(indexFile, "Class Index");

   WriteTopLinks(indexFile, 0);

   indexFile << "<h1>Class Index</h1>" << std::endl;

   WriteModuleLinks(indexFile);

   std::vector<std::string> indexChars;
   if (fHtml->GetListOfClasses()->GetSize() > 10) {
      std::vector<std::string> classNames;
      {
         TIter iClass(fHtml->GetListOfClasses());
         TClassDocInfo* cdi = 0;
         while ((cdi = (TClassDocInfo*)iClass()))
            if (cdi->IsSelected() && cdi->HaveSource())
               classNames.push_back(cdi->GetName());
      }

      if (classNames.size() > 10) {
         indexFile << "<div id=\"indxShortX\"><h4>Jump to</h4>" << std::endl;
         // find index chars
         GetIndexChars(classNames, 50 /*sections*/, indexChars);
         for (UInt_t iIdxEntry = 0; iIdxEntry < indexChars.size(); ++iIdxEntry) {
            indexFile << "<a href=\"#idx" << iIdxEntry << "\">";
            ReplaceSpecialChars(indexFile, indexChars[iIdxEntry].c_str());
            indexFile << "</a>" << std::endl;
         }
         indexFile << "</div><br />" << std::endl;
      }
   }

   indexFile << "<ul id=\"indx\">" << std::endl;

   // loop on all classes
   UInt_t currentIndexEntry = 0;
   TIter iClass(fHtml->GetListOfClasses());
   TClassDocInfo* cdi = 0;
   Int_t i = 0;
   while ((cdi = (TClassDocInfo*)iClass())) {
      if (!cdi->IsSelected() || !cdi->HaveSource())
         continue;

      // get class
      TDictionary *currentDict = cdi->GetClass();
      TClass* currentClass = dynamic_cast<TClass*>(currentDict);
      if (!currentClass) {
         if (!currentDict)
            Warning("THtml::CreateClassIndex", "skipping class %s\n", cdi->GetName());
         continue;
      }

      indexFile << "<li class=\"idxl" << (i++)%2 << "\">";
      if (currentIndexEntry < indexChars.size()
         && !strncmp(indexChars[currentIndexEntry].c_str(), cdi->GetName(),
                     indexChars[currentIndexEntry].length()))
         indexFile << "<a name=\"idx" << currentIndexEntry++ << "\"></a>";

      TString htmlFile(cdi->GetHtmlFileName());
      if (htmlFile.Length()) {
         indexFile << "<a href=\"";
         indexFile << htmlFile;
         indexFile << "\"><span class=\"typename\">";
         ReplaceSpecialChars(indexFile, cdi->GetName());
         indexFile << "</span></a> ";
      } else {
         indexFile << "<span class=\"typename\">";
         ReplaceSpecialChars(indexFile, cdi->GetName());
         indexFile << "</span> ";
      }

      // write title == short doc
      ReplaceSpecialChars(indexFile, currentClass->GetTitle());
      indexFile << "</li>" << std::endl;
   }

   indexFile << "</ul>" << std::endl;

   // write indexFile footer
   WriteHtmlFooter(indexFile);
}


//______________________________________________________________________________
void TDocOutput::CreateModuleIndex()
{
   // Create the class index for each module, picking up documentation from the
   // module's TModuleDocInfo::GetInputPath() plus the (possibly relative)
   // THtml::GetModuleDocPath(). Also creates the library dependency plot if dot
   // exists, see THtml::HaveDot().

   const char* title = "LibraryDependencies";
   TString dotfilename(title);
   gSystem->PrependPathName(fHtml->GetOutputDir(), dotfilename);

   std::ofstream libDepDotFile(dotfilename + ".dot");
   libDepDotFile << "digraph G {" << std::endl
                 << "ratio=compress;" << std::endl
                 << "node [fontsize=22,labeldistance=0.1];" << std::endl
                 << "edge [len=0.01];" << std::endl
                 << "fontsize=22;" << std::endl
                 << "size=\"16,16\";" << std::endl
                 << "overlap=false;" << std::endl
                 << "splines=true;" << std::endl
                 << "K=0.1;" << std::endl;

   TModuleDocInfo* module = 0;
   TIter iterModule(fHtml->GetListOfModules());

   std::stringstream sstrCluster;
   std::stringstream sstrDeps;
   while ((module = (TModuleDocInfo*)iterModule())) {
      if (!module->IsSelected())
         continue;

      std::vector<std::string> indexChars;
      TString filename(module->GetName());
      filename.ToUpper();
      filename.ReplaceAll("/","_");
      filename += "_Index.html";
      gSystem->PrependPathName(fHtml->GetOutputDir(), filename);
      std::ofstream outputFile(filename.Data());
      if (!outputFile.good()) {
         Error("CreateModuleIndex", "Can't open file '%s' !", filename.Data());
         continue;
      }
      Printf(fHtml->GetCounterFormat(), "", fHtml->GetCounter(), filename.Data());

      TString htmltitle("Index of ");
      TString moduletitle(module->GetName());
      moduletitle.ToUpper();
      htmltitle += moduletitle;
      WriteHtmlHeader(outputFile, htmltitle);

      WriteTopLinks(outputFile, module);

      outputFile << "<h2>" << htmltitle << "</h2>" << std::endl;

      // Module doc
      if (GetHtml()->GetModuleDocPath().Length()) {
         TString outdir(module->GetName());
         gSystem->PrependPathName(GetHtml()->GetOutputDir(), outdir);

         TString moduleDocDir;
         GetHtml()->GetPathDefinition().GetDocDir(module->GetName(), moduleDocDir);
         ProcessDocInDir(outputFile, moduleDocDir, outdir, module->GetName());
      }

      WriteModuleLinks(outputFile, module);

      std::list<std::string> classNames;
      {
         TIter iClass(module->GetClasses());
         TClassDocInfo* cdi = 0;
         while ((cdi = (TClassDocInfo*) iClass())) {
            if (!cdi->IsSelected() || !cdi->HaveSource())
               continue;
            classNames.push_back(cdi->GetName());

            if (classNames.size() > 1) continue;

            TClass* cdiClass = dynamic_cast<TClass*>(cdi->GetClass());
            if (!cdiClass)
               continue;

            TString libs(cdiClass->GetSharedLibs());
            Ssiz_t posDepLibs = libs.Index(' ');
            TString thisLib(libs);
            if (posDepLibs != kNPOS)
               thisLib.Remove(posDepLibs, thisLib.Length());

            {
               Ssiz_t posExt = thisLib.First('.');
               if (posExt != kNPOS)
                  thisLib.Remove(posExt, thisLib.Length());
            }

            if (!thisLib.Length())
               continue;

            // allocate entry, even if no dependencies
            TLibraryDocInfo *libdeps =
               (TLibraryDocInfo*)fHtml->GetLibraryDependencies()->FindObject(thisLib);
            if (!libdeps) {
               libdeps = new TLibraryDocInfo(thisLib);
               fHtml->GetLibraryDependencies()->Add(libdeps);
            }
            libdeps->AddModule(module->GetName());
            if (posDepLibs != kNPOS) {
               std::string lib;
               for(Ssiz_t pos = posDepLibs + 1; libs[pos]; ++pos) {
                  if (libs[pos] == ' ') {
                     if (thisLib.Length() && lib.length()) {
                        size_t posExt = lib.find('.');
                        if (posExt != std::string::npos)
                           lib.erase(posExt);
                        libdeps->AddDependency(lib);
                     }
                     lib.erase();
                  } else
                     lib += libs[pos];
               }
               if (lib.length() && thisLib.Length()) {
                  size_t posExt = lib.find('.');
                  if (posExt != std::string::npos)
                     lib.erase(posExt);
                  libdeps->AddDependency(lib);
               }
            } // if dependencies
         } // while next class in module
      } // just a scope block

      TIter iClass(module->GetClasses());
      TClassDocInfo* cdi = 0;
      UInt_t count = 0;
      UInt_t currentIndexEntry = 0;
      while ((cdi = (TClassDocInfo*) iClass())) {
         if (!cdi->IsSelected() || !cdi->HaveSource())
            continue;

         TDictionary *classPtr = cdi->GetClass();
         if (!classPtr) {
            Error("CreateModuleIndex", "Unknown class '%s' !", cdi->GetName());
            continue;
         }

         if (!count) {
            outputFile << "<h2>Class Index</h2>" << std::endl;

            if (classNames.size() > 10) {
               outputFile << "<div id=\"indxShortX\"><h4>Jump to</h4>" << std::endl;
               UInt_t numSections = classNames.size() / 10;
               if (numSections < 10) numSections = 10;
               if (numSections > 50) numSections = 50;
               // find index chars
               GetIndexChars(classNames, numSections, indexChars);
               for (UInt_t iIdxEntry = 0; iIdxEntry < indexChars.size(); ++iIdxEntry) {
                  outputFile << "<a href=\"#idx" << iIdxEntry << "\">";
                  ReplaceSpecialChars(outputFile, indexChars[iIdxEntry].c_str());
                  outputFile << "</a>" << std::endl;
               }
               outputFile << "</div><br />" << std::endl;
            }

            outputFile << "<ul id=\"indx\">" << std::endl;
         }

         // write a classname to an index file
         outputFile << "<li class=\"idxl" << (count++)%2 << "\">";
         if (currentIndexEntry < indexChars.size()
            && !strncmp(indexChars[currentIndexEntry].c_str(), cdi->GetName(),
                        indexChars[currentIndexEntry].length()))
            outputFile << "<a name=\"idx" << currentIndexEntry++ << "\"></a>";

         TString htmlFile(cdi->GetHtmlFileName());
         if (htmlFile.Length()) {
            outputFile << "<a href=\"";
            outputFile << htmlFile;
            outputFile << "\"><span class=\"typename\">";
            ReplaceSpecialChars(outputFile, classPtr->GetName());
            outputFile << "</span></a> ";
         } else {
            outputFile << "<span class=\"typename\">";
            ReplaceSpecialChars(outputFile, classPtr->GetName());
            outputFile << "</span> ";
         }

         // write title
         ReplaceSpecialChars(outputFile, classPtr->GetTitle());
         outputFile << "</li>" << std::endl;
      }


      if (count)
         outputFile << "</ul>" << std::endl;

      // write outputFile footer
      WriteHtmlFooter(outputFile);
   } // while next module

   // libCint is missing as we don't have class doc for it
   // We need it for dependencies nevertheless, so add it by hand.
   /*
   sstrCluster << "subgraph clusterlibCint {" << std::endl
      << "style=filled;" << std::endl
      << "color=lightgray;" << std::endl
      << "label=\"libCint\";" << std::endl
      << "\"CINT\" [style=filled,color=white,fontsize=10]" << std::endl
      << "}" << std::endl;
   */

   // simplify the library dependencies, by removing direct links
   // that are equivalent to indirect ones, e.g. instead of having both
   // A->C, A->B->C, keep only A->B->C.

   TIter iLib(fHtml->GetLibraryDependencies());
   TLibraryDocInfo* libinfo = 0;
   while ((libinfo = (TLibraryDocInfo*)iLib())) {
      if (!libinfo->GetName() || !libinfo->GetName()[0]) continue;

      std::set<std::string>& deps = libinfo->GetDependencies();
      for (std::set<std::string>::iterator iDep = deps.begin();
           iDep != deps.end(); ) {
         Bool_t already_indirect = kFALSE;
         for (std::set<std::string>::const_iterator iDep2 = deps.begin();
              !already_indirect && iDep2 != deps.end(); ++iDep2) {
            if (iDep == iDep2) continue;
            TLibraryDocInfo* libinfo2 = (TLibraryDocInfo*)
               fHtml->GetLibraryDependencies()->FindObject(iDep2->c_str());
            if (!libinfo2) continue;
            const std::set<std::string>& deps2 = libinfo2->GetDependencies();
            already_indirect |= deps2.find(*iDep) != deps2.end();
         }
         if (already_indirect) {
            std::set<std::string>::iterator iRemove = iDep;
            // Advance the iterator before erasing the element which invalidates the iterator.
            ++iDep;
            deps.erase(iRemove);
         } else {
            ++iDep;
         }
      } // for library dependencies of module in library
   } // for libaries

   iLib.Reset();
   while ((libinfo = (TLibraryDocInfo*)iLib())) {
      if (!libinfo->GetName() || !libinfo->GetName()[0]) continue;

      const std::set<std::string>& modules = libinfo->GetModules();
      if (modules.size() > 1) {
         sstrCluster << "subgraph cluster" << libinfo->GetName() << " {" << std::endl
                     << "style=filled;" << std::endl
                     << "color=lightgray;" << std::endl
                     << "label=\"";
         if (!strcmp(libinfo->GetName(), "libCore"))
            sstrCluster << "Everything depends on ";
         sstrCluster << libinfo->GetName() << "\";" << std::endl;

         for (std::set<std::string>::const_iterator iModule = modules.begin();
              iModule != modules.end(); ++iModule) {
            TString modURL(*iModule);
            modURL.ReplaceAll("/", "_");
            modURL.ToUpper();
            sstrCluster << "\"" << *iModule << "\" [style=filled,color=white,URL=\""
                        << modURL << "_Index.html\"];" << std::endl;
         }
         sstrCluster << std::endl
                     << "}" << std::endl;
      } else {
         // only one module
         TString modURL(*modules.begin());
         modURL.ReplaceAll("/", "_");
         modURL.ToUpper();
         sstrCluster << "\"" << *modules.begin()
                     << "\" [label=\"" << libinfo->GetName()
                     << "\",style=filled,color=lightgray,shape=box,URL=\""
                     << modURL << "_Index.html\"];" << std::endl;
      }

      // GetSharedLib doesn't mention libCore or libCint; add them by hand
      /*
        if (iLibDep->first != "libCore")
        sstrDeps << "\"" << iModule->first << "\" -> \"BASE\" [lhead=clusterlibCore];" << std::endl;
        sstrDeps << "\"" << iModule->first << "\" -> \"CINT\" [lhead=clusterlibCint];" << std::endl;
      */

      const std::string& mod = *(modules.begin());
      const std::set<std::string>& deps = libinfo->GetDependencies();
      for (std::set<std::string>::const_iterator iDep = deps.begin();
            iDep != deps.end(); ++iDep) {
         // cannot create dependency on iDep directly, use its first module instead.
         TLibraryDocInfo* depLibInfo = (TLibraryDocInfo*)
            fHtml->GetLibraryDependencies()->FindObject(iDep->c_str());
         if (!depLibInfo || depLibInfo->GetModules().empty())
            continue; // ouch!

         const std::string& moddep = *(depLibInfo->GetModules().begin());
         sstrDeps << "\"" << mod << "\" -> \"" << moddep << "\";" << std::endl;
      }
      // make sure libCore ends up at the bottom
      sstrDeps << "\"" << mod <<  "\" -> \"CONT\" [style=invis];" << std::endl;
   } // for libs

   libDepDotFile << sstrCluster.str() << std::endl
      << sstrDeps.str();
   libDepDotFile << "}" << std::endl;
   libDepDotFile.close();

   std::ofstream out(dotfilename + ".html");
   if (!out.good()) {
      Error("CreateModuleIndex", "Can't open file '%s.html' !",
            dotfilename.Data());
      return;
   }

   Printf(fHtml->GetCounterFormat(), "", fHtml->GetCounter(), (dotfilename + ".html").Data());
   // write out header
   WriteHtmlHeader(out, "Library Dependencies");

   WriteTopLinks(out, 0);

   out << "<h1>Library Dependencies</h1>" << std::endl;

   RunDot(dotfilename, &out, kFdp);

   out << "<img alt=\"Library Dependencies\" class=\"classcharts\" usemap=\"#Map" << title << "\" src=\"" << title << ".png\"/>" << std::endl;

   // write out footer
   WriteHtmlFooter(out);
}

//______________________________________________________________________________
void TDocOutput::CreateProductIndex()
{
   // Fetch documentation from THtml::GetProductDocDir() and put it into the
   // product index page.

   //TString outFile(GetHtml()->GetProductName());
   //outFile += ".html";
   TString outFile("index.html");
   gSystem->PrependPathName(GetHtml()->GetOutputDir(), outFile);
   std::ofstream out(outFile);

   if (!out.good()) {
      Error("CreateProductIndex", "Can't open file '%s' !", outFile.Data());
      return;
   }

   Printf(fHtml->GetCounterFormat(), "", "", outFile.Data());

   WriteHtmlHeader(out, GetHtml()->GetProductName() + " Reference Guide");

   WriteTopLinks(out, 0);

   out << "<h1>" << GetHtml()->GetProductName() + " Reference Guide</h1>" << std::endl;

   TString prodDoc;
   if (GetHtml()->GetPathDefinition().GetDocDir("", prodDoc))
      ProcessDocInDir(out, prodDoc, GetHtml()->GetOutputDir(), "./");

   WriteModuleLinks(out);

   out << "<h2>Chapters</h2>" << std::endl
      << "<h3><a href=\"./ClassIndex.html\">Class Index</a></h3>" << std::endl
      << "<p>A complete list of all classes defined in " << GetHtml()->GetProductName() << "</p>" << std::endl
      << "<h3><a href=\"./ClassHierarchy.html\">Class Hierarchy</a></h3>" << std::endl
      << "<p>A hierarchy graph of all classes, showing each class's base and derived classes</p>" << std::endl
      << "<h3><a href=\"./ListOfTypes.html\">Type Index</a></h3>" << std::endl
      << "<p>A complete list of all types</p>" << std::endl
      << "<h3><a href=\"./LibraryDependencies.html\">Library Dependency</a></h3>" << std::endl
      << "<p>A diagram showing all of " << GetHtml()->GetProductName() << "'s libraries and their dependencies</p>" << std::endl;

   WriteHtmlFooter(out);
}

//______________________________________________________________________________
void TDocOutput::CreateClassTypeDefs()
{
   // Create a forwarding page for each typedef pointing to a class.
   TDocParser parser(*this);

   TIter iClass(GetHtml()->GetListOfClasses());
   TClassDocInfo* cdi = 0;
   while ((cdi = (TClassDocInfo*) iClass())) {
      if (cdi->GetListOfTypedefs().IsEmpty())
         continue;
      TIter iTypedefs(&cdi->GetListOfTypedefs());
      TDataType* dt = 0;
      while ((dt = (TDataType*) iTypedefs())) {
         if (gDebug > 0)
            Info("CreateClassTypeDefs", "Creating typedef %s to class %s",
                 dt->GetName(), cdi->GetName());
         // create a filename
         TString filename(dt->GetName());
         NameSpace2FileName(filename);

         gSystem->PrependPathName(fHtml->GetOutputDir(), filename);

         filename += ".html";

         // open class file
         std::ofstream outfile(filename);

         if (!outfile.good()) {
            Error("CreateClassTypeDefs", "Can't open file '%s' !", filename.Data());
            continue;
         }

         WriteHtmlHeader(outfile, dt->GetName());

         outfile << "<a name=\"TopOfPage\"></a>" << std::endl;

         TString dtName(dt->GetName());
         ReplaceSpecialChars(dtName);
         TString sTitle("typedef ");
         sTitle += dtName;

         TClass* cls = dynamic_cast<TClass*>(cdi->GetClass());
         if (cls) {
            // show box with lib, include
            // needs to go first to allow title on the left
            TString sInclude;
            TString sLib;
            const char* lib=cls->GetSharedLibs();
            GetHtml()->GetPathDefinition().GetIncludeAs(cls, sInclude);
            if (lib) {
               char* libDup=StrDup(lib);
               char* libDupSpace=strchr(libDup,' ');
               if (libDupSpace) *libDupSpace = 0;
               char* libDupEnd=libDup+strlen(libDup);
               while (libDupEnd!=libDup)
                  if (*(--libDupEnd)=='.') {
                     *libDupEnd=0;
                     break;
                  }
               sLib = libDup;
               delete[] libDup;
            }
            outfile << "<script type=\"text/javascript\">WriteFollowPageBox('"
                    << sTitle << "','" << sLib << "','" << sInclude << "');</script>" << std::endl;
         }

         TString modulename;
         fHtml->GetModuleNameForClass(modulename, cls);
         TModuleDocInfo* module = (TModuleDocInfo*) fHtml->GetListOfModules()->FindObject(modulename);
         WriteTopLinks(outfile, module, dt->GetName());

         outfile << "<div class=\"dropshadow\"><div class=\"withshadow\">";
         outfile << "<h1>" << sTitle << "</h1>" << std::endl
            << "<div class=\"classdescr\">" << std::endl;

         outfile << dtName << " is a typedef to ";
         std::string shortClsName(fHtml->ShortType(cdi->GetName()));
         parser.DecorateKeywords(outfile, shortClsName.c_str());
         outfile << std::endl
            << "</div>" << std::endl
            << "</div></div><div style=\"clear:both;\"></div>" << std::endl;

         // the typedef isn't a data member, but the CSS is applicable nevertheless
         outfile << std::endl << "<div id=\"datamembers\">" << std::endl
            << "<table class=\"data\" cellspacing=\"0\">" << std::endl;
         outfile << "<tr class=\"data";
         outfile << "\"><td class=\"datatype\">typedef ";
         parser.DecorateKeywords(outfile, dt->GetFullTypeName());
         outfile << "</td><td class=\"dataname\">";
         ReplaceSpecialChars(outfile, dt->GetName());
         if (dt->GetTitle() && dt->GetTitle()[0]) {
            outfile << "</td><td class=\"datadesc\">";
            ReplaceSpecialChars(outfile, dt->GetTitle());
         } else outfile << "</td><td>";
         outfile << "</td></tr>" << std::endl
            << "</table></div>" << std::endl;

         // write footer
         WriteHtmlFooter(outfile);

      }
   }
}

//______________________________________________________________________________
void TDocOutput::CreateTypeIndex()
{
// Create index of all data types

   // open file
   TString outFile("ListOfTypes.html");
   gSystem->PrependPathName(fHtml->GetOutputDir(), outFile);
   std::ofstream typesList(outFile);

   if (!typesList.good()) {
      Error("CreateTypeIndex", "Can't open file '%s' !", outFile.Data());
      return;
   }

   Printf(fHtml->GetCounterFormat(), "", "", outFile.Data());

   // write typesList header
   WriteHtmlHeader(typesList, "List of data types");
   typesList << "<h2> List of data types </h2>" << std::endl;

   typesList << "<dl><dd>" << std::endl;

   // make loop on data types
   std::vector<std::string> typeNames(gROOT->GetListOfTypes()->GetSize());

   {
      TDataType *type;
      TIter nextType(gROOT->GetListOfTypes());
      size_t tnIdx = 0;

      while ((type = (TDataType *) nextType()))
         // no templates ('<' and '>'), no idea why the '(' is in here...
         if (*type->GetTitle() && !strchr(type->GetName(), '(')
             && !( strchr(type->GetName(), '<') && strchr(type->GetName(),'>'))
             && type->GetName())
            typeNames[tnIdx++] = type->GetName();
      typeNames.resize(tnIdx);
   }

   sort_strlist_stricmp(typeNames);

   std::vector<std::string> indexChars;
   if (typeNames.size() > 10) {
      typesList << "<div id=\"indxShortX\"><h4>Jump to</h4>" << std::endl;
      // find index chars
      GetIndexChars(typeNames, 10 /*sections*/, indexChars);
      for (UInt_t iIdxEntry = 0; iIdxEntry < indexChars.size(); ++iIdxEntry) {
         typesList << "<a href=\"#idx" << iIdxEntry << "\">";
         ReplaceSpecialChars(typesList, indexChars[iIdxEntry].c_str());
         typesList << "</a>" << std::endl;
      }
      typesList << "</div><br />" << std::endl;
   }

   typesList << "<ul id=\"indx\">" << std::endl;

   int idx = 0;
   UInt_t currentIndexEntry = 0;

   for (std::vector<std::string>::iterator iTypeName = typeNames.begin();
      iTypeName != typeNames.end(); ++iTypeName) {
      TDataType* type = gROOT->GetType(iTypeName->c_str(), kFALSE);
      typesList << "<li class=\"idxl" << idx%2 << "\">";
      if (currentIndexEntry < indexChars.size()
         && !strncmp(indexChars[currentIndexEntry].c_str(), iTypeName->c_str(),
                     indexChars[currentIndexEntry].length()))
         typesList << "<a name=\"idx" << currentIndexEntry++ << "\"></a>" << std::endl;
      typesList << "<a name=\"";
      ReplaceSpecialChars(typesList, iTypeName->c_str());
      typesList << "\"><span class=\"typename\">";
      ReplaceSpecialChars(typesList, iTypeName->c_str());
      typesList << "</span></a> ";
      ReplaceSpecialChars(typesList, type->GetTitle());
      typesList << "</li>" << std::endl;
      ++idx;
   }
   typesList << "</ul>" << std::endl;

   // write typesList footer
   WriteHtmlFooter(typesList);

   // close file
   typesList.close();

}


//______________________________________________________________________________
void TDocOutput::DecorateEntityBegin(TString& str, Ssiz_t& pos, TDocParser::EParseContext type)
{
   // Add some colors etc to a source entity, contained in str.
   // The type of what's contained in str is given by type.
   // It's called e.g. by TDocParser::BeautifyLine().
   // This function should assume that only str.Begin() is valid.
   // When inserting into str.String(), str.Begin() must be updated.

   Ssiz_t originalLen = str.Length();

   switch (type) {
      case TDocParser::kCode: break;
      case TDocParser::kComment:
         str.Insert(pos, "<span class=\"comment\">");
         break;
      case TDocParser::kDirective:
         break;
      case TDocParser::kString:
         str.Insert(pos, "<span class=\"string\">");
         break;
      case TDocParser::kKeyword:
         str.Insert(pos, "<span class=\"keyword\">");
         break;
      case TDocParser::kCPP:
         str.Insert(pos, "<span class=\"cpp\">");
         break;
      case TDocParser::kVerbatim:
         str.Insert(pos, "<pre>");
         break;
      default:
         Error("DecorateEntityBegin", "Unhandled / invalid entity type %d!", (Int_t)type);
         return;
   }

   Ssiz_t addedLen = str.Length() - originalLen;
   pos += addedLen;
}

//______________________________________________________________________________
void TDocOutput::DecorateEntityEnd(TString& str, Ssiz_t& pos, TDocParser::EParseContext type)
{
   // Add some colors etc to a source entity, contained in str.
   // The type of what's contained in str is given by type.
   // It's called e.g. by TDocParser::BeautifyLine().
   // This function should assume that only str."End()"
   // (i.e. str.Begin()+str.Length()) is valid.
   // When inserting into str.String(), str.Length() must be updated.

   Ssiz_t originalLen = str.Length();

   switch (type) {
      case TDocParser::kCode: break;
      case TDocParser::kComment:
         str.Insert(pos, "</span>");
         break;
      case TDocParser::kDirective:
         break;
      case TDocParser::kString:
         str.Insert(pos, "</span>");
         break;
      case TDocParser::kKeyword:
         str.Insert(pos, "</span>");
         break;
      case TDocParser::kCPP:
         str.Insert(pos, "</span>");
         break;
      case TDocParser::kVerbatim:
         str.Insert(pos, "</pre>");
         break;
      default:
         Error("DecorateEntityBegin", "Unhandled / invalid entity type %d!", (Int_t)type);
         return;
   }
   Ssiz_t addedLen = str.Length() - originalLen;
   pos += addedLen;
}

//______________________________________________________________________________
void TDocOutput::FixupAuthorSourceInfo(TString& authors)
{
// Special author treatment; called when TDocParser::fSourceInfo[kInfoAuthor] is set.
// Modifies the author(s) description, which is a comma separated list of tokens
// either in the format
// (i) "FirstName LastName " or
// (ii) "FirstName LastName <link> more stuff"
// The first one generates an XWho link (CERN compatible),
// the second a http link (WORLD compatible), <link> being e.g.
// <mailto:user@host.bla> or <http://www.host.bla/page>.

   TString original(authors);
   authors = "";

   TString author;
   Ssiz_t pos = 0;
   Bool_t firstAuthor = kTRUE;
   while (original.Tokenize(author, pos, ",")) {
      author.Strip(TString::kBoth);

      if (!firstAuthor)
         authors += ", ";
      firstAuthor = kFALSE;

      // do we have a link for the current name?
      Ssiz_t cLink = author.First('<'); // look for link start tag
      if (cLink != kNPOS) {
         // split NAME <LINK> POST
         // into  <a href="LINK">NAME</a> POST
         Ssiz_t endLink = author.Index(">", cLink + 1);
         if(endLink == kNPOS)
            endLink = author.Length();
         authors += "<a href=\"";
         authors += author(cLink + 1,  endLink - (cLink + 1));
         authors += "\">";
         authors += author(0, cLink);
         authors += "</a>";
         if (endLink != author.Length())
            authors += author(endLink + 1, author.Length());
      } else {
         authors += "<a href=\"";
         authors += fHtml->GetXwho();

         // separate Firstname Middlename Lastname by '+'
         TString namePart;
         Ssiz_t posNamePart = 0;
         Bool_t firstNamePart = kTRUE;
         while (author.Tokenize(namePart, posNamePart, " ")) {
            namePart.Strip(TString::kBoth);
            if (!namePart.Length())
               continue;
            if (isdigit(namePart[0])) continue; //likely a date
            if (!firstNamePart)
               authors += '+';
            firstNamePart = kFALSE;
            authors += namePart;
         }
         authors += "\">";
         authors += author;
         authors += "</a>";
      }
   } // while next author
}

//______________________________________________________________________________
Bool_t TDocOutput::IsModified(TClass * classPtr, EFileType type)
{
// Check if file is modified
//
//
//  Input: classPtr - pointer to the class
//         type     - file type to compare with
//                    values: kSource, kInclude, kTree
//
// Output: TRUE     - if file is modified since last time
//         FALSE    - if file is up to date
//

   TString sourceFile;
   TString classname(classPtr->GetName());
   TString filename;
   TString dir;

   switch (type) {
   case kSource:
      {
         TString declFile;
         if (classPtr->GetImplFileLine()) {
            fHtml->GetImplFileName(classPtr, kTRUE, sourceFile);
         }
         fHtml->GetDeclFileName(classPtr, kTRUE, declFile);
         Long64_t size;
         Long_t id, flags, iModtime, dModtime;
         if (!(gSystem->GetPathInfo(sourceFile, &id, &size, &flags, &iModtime))) {
            if (!(gSystem->GetPathInfo(declFile, &id, &size, &flags, &dModtime))) {
               if (iModtime < dModtime) {
                  // decl is newer than impl
                  sourceFile = declFile;
               }
            }
         }
         dir = "src";
         gSystem->PrependPathName(fHtml->GetOutputDir(), dir);
         filename = classname;
         NameSpace2FileName(filename);
         gSystem->PrependPathName(dir, filename);
         if (classPtr->GetImplFileLine())
            filename += ".cxx.html";
         else
            filename += ".h.html";
         break;
      }

   case kInclude:
      fHtml->GetDeclFileName(classPtr, kFALSE, filename);
      filename = gSystem->BaseName(filename);
      fHtml->GetDeclFileName(classPtr, kTRUE, sourceFile);
      gSystem->PrependPathName(fHtml->GetOutputDir(), filename);
      break;

   case kTree:
      fHtml->GetDeclFileName(classPtr, kTRUE, sourceFile);
      NameSpace2FileName(classname);
      gSystem->PrependPathName(fHtml->GetOutputDir(), classname);
      filename = classname;
      filename += "_Tree.pdf";
      break;

   case kDoc:
      {
         TString declFile;
         if (classPtr->GetImplFileLine()) {
            fHtml->GetImplFileName(classPtr, kTRUE, sourceFile);
         }
         fHtml->GetDeclFileName(classPtr, kTRUE, declFile);
         Long64_t size;
         Long_t id, flags, iModtime, dModtime;
         if (!(gSystem->GetPathInfo(sourceFile, &id, &size, &flags, &iModtime))) {
            if (!(gSystem->GetPathInfo(declFile, &id, &size, &flags, &dModtime))) {
               if (iModtime < dModtime) {
                  // decl is newer than impl
                  sourceFile = declFile;
               }
            }
         }
         filename = classname;
         NameSpace2FileName(filename);
         gSystem->PrependPathName(fHtml->GetOutputDir(), filename);
         filename += ".html";
         break;
      }

   default:
      Error("IsModified", "Unknown file type !");
   }

   R__LOCKGUARD(GetHtml()->GetMakeClassMutex());

   // Get info about a file
   Long64_t size;
   Long_t id, flags, sModtime, dModtime;

   if (!(gSystem->GetPathInfo(sourceFile, &id, &size, &flags, &sModtime))) {
      if (!(gSystem->GetPathInfo(filename, &id, &size, &flags, &dModtime))) {
         return (sModtime > dModtime);
      }
   }

   return kTRUE;
}


//______________________________________________________________________________
void TDocOutput::NameSpace2FileName(TString& name)
{
   // Replace "::" in name by "__"
   // Replace "<", ">", " ", ",", "~", "=" in name by "_"
   // Replace "A::X<A::Y>" by "A::X<-p0Y>",
   //         "A::B::X<A::B::Y>" by "A::B::X<-p1Y>", etc

   TString encScope(name);
   Ssiz_t posTemplate = encScope.Index('<');
   if (posTemplate != kNPOS) {
      // strip default template params
      name = fHtml->ShortType(name);
      TString templateArgs = encScope(posTemplate, encScope.Length());
      encScope.Remove(posTemplate, encScope.Length());
      // shorten the name a bit:
      // convert A::B::X<A::B::Y> to A::X<-p1Y>, i.e.
      // the filename A__X_A__Y_ to A__X_-p1Y_
      // The rule: if the enclosing scope up to the N-th scope matches,
      // the name becomes -pN
      Ssiz_t posName = encScope.Last(':');
      if (posName != kNPOS) {
         Int_t numDblColumn = encScope.CountChar(':');
         while (numDblColumn > 1) {
            encScope.Remove(posName + 1, encScope.Length());
            numDblColumn -= 2;
            templateArgs.ReplaceAll(encScope, TString::Format("-p%d", numDblColumn / 2));
            encScope.Remove(encScope.Length() - 2, 2);
            posName = encScope.Last(':');
            if (posName == kNPOS)
               break; // should be handled by numDblColumn...
         }
         name.Replace(posTemplate, name.Length(), templateArgs);
      }
   }

   if (name.Length() > 240) { // really 240! It might get some extra prefix or extension
      // 8.3 is dead, but e.g. ext2 can only hold 255 chars in a file name.
      // So mangle name to "beginning_of_name"-h"hash"."extension", where
      // beginning_of_name is short enough such that the full name is <255 characters.

      TString hash;
      TDocParser::AnchorFromLine(name, hash);
      hash.Prepend("-h");
      Ssiz_t posDot = name.Last('.');
      TString ext;
      if (posDot != kNPOS)
         ext = name(posDot, name.Length());
      Ssiz_t namelen = 240 - hash.Length() - ext.Length();
      name = name(0, namelen) + hash + ext;
   }

   const char* replaceWhat = ":<> ,~=";
   for (Ssiz_t i=0; i < name.Length(); ++i)
      if (strchr(replaceWhat, name[i]))
         name[i] = '_';
}

//______________________________________________________________________________
void TDocOutput::ProcessDocInDir(std::ostream& out, const char* indir,
                                 const char* outdir, const char* linkdir)
{
   // Write links to files indir/*.txt, indir/*.html (non-recursive) to out.
   // If one of the files is called "index.{html,txt}" it will be
   // included in out (instead of copying it to outdir and generating a link
   // to linkdir). txt files are passed through Convert().
   // The files' links are sorted alphabetically.

   R__LOCKGUARD(GetHtml()->GetMakeClassMutex());

   void * dirHandle = gSystem->OpenDirectory(indir);
   if (!dirHandle) return;

   const char* entry = 0;
   std::list<std::string> files;
   while ((entry = gSystem->GetDirEntry(dirHandle))) {
      FileStat_t stat;
      TString filename(entry);
      gSystem->PrependPathName(indir, filename);
      if (gSystem->GetPathInfo(filename, stat)) // funny ret
         continue;
      if (!R_ISREG(stat.fMode)) continue;

      if (TString(entry).BeginsWith("index.", TString::kIgnoreCase)) {
         // This is the part we put directly (verbatim) into the module index.
         // If it ends on ".txt" we run Convert first.
         if (filename.EndsWith(".txt", TString::kIgnoreCase)) {
            std::ifstream in(filename);
            if (in) {
               out << "<pre>"; // this is what e.g. the html directive expects
               TDocParser parser(*this);
               parser.Convert(out, in, "./", kFALSE /* no code */, kTRUE /*process Directives*/);
               out << "</pre>";
            }
         } else if (filename.EndsWith(".html", TString::kIgnoreCase)) {
            std::ifstream in(filename);
            TString line;
            while (in) {
               if (!line.ReadLine(in)) break;
               out << line << std::endl;
            }
         } else
            files.push_back(filename.Data());
      } else
         files.push_back(filename.Data());
   }

   std::stringstream furtherReading;
   files.sort();
   for (std::list<std::string>::const_iterator iFile = files.begin();
      iFile != files.end(); ++iFile) {
      TString filename(iFile->c_str());
      if (gSystem->AccessPathName(outdir))
         if (gSystem->mkdir(outdir, kTRUE) == -1)
            // bad - but let's still try to create the output
            Error("CreateModuleIndex", "Cannot create output directory %s", outdir);

      TString outfile(gSystem->BaseName(filename));
      gSystem->PrependPathName(outdir, outfile);

      if (!filename.EndsWith(".txt", TString::kIgnoreCase)
          && !filename.EndsWith(".html", TString::kIgnoreCase)) {
         // copy to outdir, who know whether it's needed...
         if (gSystem->CopyFile(filename, outfile, kTRUE) == -1) {
            Error("CreateModuleIndex", "Cannot copy file %s to %s",
                  filename.Data(), outfile.Data());
            continue;
         }
         continue;
      }

      // Just copy and link this page.
      if (outfile.EndsWith(".txt", TString::kIgnoreCase)) {
         // convert first
         outfile.Remove(outfile.Length()-3, 3);
         outfile += "html";
         std::ifstream inFurther(filename);
         std::ofstream outFurther(outfile);
         if (inFurther && outFurther) {
            outFurther << "<pre>"; // this is what e.g. the html directive expects
            TDocParser parser(*this);
            parser.Convert(outFurther, inFurther, "../", kFALSE /*no code*/, kTRUE /*process Directives*/);
            outFurther << "</pre>";
         }
      } else {
         if (gSystem->CopyFile(filename, outfile, kTRUE) == -1)
            continue;
      }
      TString showname(gSystem->BaseName(outfile));
      furtherReading << "<a class=\"linkeddoc\" href=\"" << linkdir << "/" << showname << "\">";
      showname.Remove(showname.Length() - 5, 5); // .html
      showname.ReplaceAll("_", " ");
      ReplaceSpecialChars(furtherReading, showname);
      furtherReading << "</a> " << std::endl;
   }

   gSystem->FreeDirectory(dirHandle);
   if (furtherReading.str().length())
      out << "<h3>Further Reading</h3><div id=\"furtherreading\">" << std::endl
          << furtherReading.str() << "</div><h3>List of Classes</h3>" << std::endl;
}

//______________________________________________________________________________
void TDocOutput::ReferenceEntity(TSubString& str, TClass* entity, const char* comment /*= 0*/)
{
   // Create a reference to a class documentation page.
   // str encloses the text to create the reference for (e.g. name of instance).
   // comment will be added e.g. as tooltip text.
   // After the reference is put into str.String(), str will enclose the reference
   // and the original text. Example:
   // Input:
   //  str.String(): "a gHtml test"
   //  str.Begin():  2
   //  str.Length(): 5
   // Output:
   //  str.String(): "a <a href="THtml.html">gHtml</a> test"
   //  str.Begin():  2
   //  str.Length(): 30

   TString link;
   fHtml->GetHtmlFileName(entity, link);

   if (comment && !strcmp(comment, entity->GetName()))
      comment = "";

   AddLink(str, link, comment);
}

//______________________________________________________________________________
void TDocOutput::ReferenceEntity(TSubString& str, TDataMember* entity, const char* comment /*= 0*/)
{
   // Create a reference to a data member documentation page.
   // str encloses the text to create the reference for (e.g. name of instance).
   // comment will be added e.g. as tooltip text.
   // After the reference is put into str.String(), str will enclose the reference
   // and the original text. Example:
   // Input:
   //  str.String(): "a gHtml test"
   //  str.Begin():  2
   //  str.Length(): 5
   // Output:
   //  str.String(): "a <a href="THtml.html">gHtml</a> test"
   //  str.Begin():  2
   //  str.Length(): 30
   TString link;
   TClass* scope = entity->GetClass();
   fHtml->GetHtmlFileName(scope, link);
   link += "#";

   TString mangledName;
   if (scope) {
      mangledName = scope->GetName();
      NameSpace2FileName(mangledName);
      link += mangledName;
      link += ":";
   }

   mangledName = entity->GetName();
   NameSpace2FileName(mangledName);
   link += mangledName;

   TString description;
   if (!comment) {
      description = entity->GetFullTypeName();
      description += " ";
      if (scope) {
         description += scope->GetName();
         description += "::";
      }
      description += entity->GetName();
      comment = description.Data();
   }

   if (comment && !strcmp(comment, entity->GetName()))
      comment = "";

   AddLink(str, link, comment);
}

//______________________________________________________________________________
void TDocOutput::ReferenceEntity(TSubString& str, TDataType* entity, const char* comment /*= 0*/)
{
   // Create a reference to a type documentation page.
   // str encloses the text to create the reference for (e.g. name of instance).
   // comment will be added e.g. as tooltip text.
   // After the reference is put into str.String(), str will enclose the reference
   // and the original text. Example:
   // Input:
   //  str.String(): "a gHtml test"
   //  str.Begin():  2
   //  str.Length(): 5
   // Output:
   //  str.String(): "a <a href="THtml.html">gHtml</a> test"
   //  str.Begin():  2
   //  str.Length(): 30

   TString mangledEntity(entity->GetName());
   NameSpace2FileName(mangledEntity);

   TString link;
   TClassDocInfo* cdi = 0;
   bool isClassTypedef = entity->GetType() == -1;
   if (isClassTypedef)
      /* is class/ struct / union */
      isClassTypedef = isClassTypedef && (entity->Property() & 7);
   if (isClassTypedef) {
      std::string shortTypeName(fHtml->ShortType(entity->GetFullTypeName()));
      cdi = (TClassDocInfo*) GetHtml()->GetListOfClasses()->FindObject(shortTypeName.c_str());
   }
   if (cdi) {
      link = mangledEntity + ".html";
   } else {
      link = "ListOfTypes.html#";
      link += mangledEntity;
   }

   if (comment && !strcmp(comment, entity->GetName()))
      comment = "";

   AddLink(str, link, comment);
}

//______________________________________________________________________________
void TDocOutput::ReferenceEntity(TSubString& str, TMethod* entity, const char* comment /*= 0*/)
{
   // Create a reference to a method documentation page.
   // str encloses the text to create the reference for (e.g. name of instance).
   // comment will be added e.g. as tooltip text.
   // After the reference is put into str.String(), str will enclose the reference
   // and the original text. Example:
   // Input:
   //  str.String(): "a gHtml test"
   //  str.Begin():  2
   //  str.Length(): 5
   // Output:
   //  str.String(): "a <a href="THtml.html">gHtml</a> test"
   //  str.Begin():  2
   //  str.Length(): 30

   TString link;
   TClass* scope = entity->GetClass();
   fHtml->GetHtmlFileName(scope, link);
   link += "#";

   TString mangledName(scope->GetName());
   NameSpace2FileName(mangledName);
   link += mangledName;
   link += ":";

   mangledName = entity->GetName();
   NameSpace2FileName(mangledName);
   link += mangledName;

   TString description;
   if (!comment && entity->GetClass()) {
      TIter iMeth(scope->GetListOfMethods());
      TMethod* mCand = 0;
      while ((mCand = (TMethod*)iMeth()))
         if (!strcmp(mCand->GetName(), entity->GetName())) {
            if (description.Length()) {
               description += " or overloads";
               break;
            }
            description = mCand->GetPrototype();
         }
      comment = description.Data();
   }

   if (comment && !strcmp(comment, entity->GetName()))
      comment = "";

   AddLink(str, link, comment);
}

//______________________________________________________________________________
Bool_t TDocOutput::ReferenceIsRelative(const char* reference) const
{
   // Check whether reference is a relative reference, and can (or should)
   // be prependen by relative paths. For HTML, check that it doesn't start
   // with "http://" or "https://"

   return !reference ||
      strncmp(reference, "http", 4) ||
      (strncmp(reference + 4, "://", 3) && strncmp(reference + 4, "s://", 4));
}

//______________________________________________________________________________
const char* TDocOutput::ReplaceSpecialChars(char c)
{
// Replace ampersand, less-than and greater-than character, writing to out.
// If 0 is returned, no replacement needs to be done.

   /*
   if (fEscFlag) {
      fEscFlag = kFALSE;
      return buf;
   } else if (c == fEsc) {
      // text.Remove(pos, 1); - NO! we want to keep it nevertheless!
      fEscFlag = kTRUE;
      return buf;
   }

   */
   switch (c) {
      case '<': return "&lt;";
      case '&': return "&amp;";
      case '>': return "&gt;";
   };
   return 0;
}

//______________________________________________________________________________
void TDocOutput::ReplaceSpecialChars(TString& text, Ssiz_t &pos)
{
// Replace ampersand, less-than and greater-than character
//
//
// Input: text - text where replacement will happen,
//        pos  - index of char to be replaced; will point to next char to be
//               replaced when function returns
//

   const char c = text[pos];
   const char* replaced = ReplaceSpecialChars(c);
   if (replaced) {
         text.Replace(pos, 1, replaced);
         pos += strlen(replaced) - 1;
   }
   ++pos;
}

//______________________________________________________________________________
void TDocOutput::ReplaceSpecialChars(TString& text) {
// Replace ampersand, less-than and greater-than character
//
//
// Input: text - text where replacement will happen,
//
   Ssiz_t pos = 0;
   while (pos < text.Length())
         ReplaceSpecialChars(text, pos);
}

//______________________________________________________________________________
void TDocOutput::ReplaceSpecialChars(std::ostream& out, const char *string)
{
// Replace ampersand, less-than and greater-than characters, writing to out
//
//
// Input: out    - output file stream
//        string - pointer to an array of characters
//

   while (string && *string) {
      const char* replaced = ReplaceSpecialChars(*string);
      if (replaced)
         out << replaced;
      else
         out << *string;
      string++;
   }
}

//______________________________________________________________________________
Bool_t TDocOutput::RunDot(const char* filename, std::ostream* outMap /* =0 */,
                          EGraphvizTool gvwhat /*= kDot*/) {
// Run filename".dot", creating filename".png", and - if outMap is !=0,
// filename".map", which gets then included literally into outMap.

   if (!fHtml->HaveDot())
      return kFALSE;

   TString runDot;
   switch (gvwhat) {
   case kNeato: runDot = "neato"; break;
   case kFdp: runDot = "fdp"; break;
   case kCirco: runDot = "circo"; break;
   default: runDot = "dot";
   };
   if (fHtml->GetDotDir() && *fHtml->GetDotDir())
      gSystem->PrependPathName(fHtml->GetDotDir(), runDot);
   runDot += " -q1 -Tpng -o";
   runDot += filename;
   runDot += ".png ";
   if (outMap) {
      runDot += "-Tcmap -o";
      runDot += filename;
      runDot += ".map ";
   }
   runDot += filename;
   runDot += ".dot";

   if (gDebug > 3)
      Info("RunDot", "Running: %s", runDot.Data());
   Int_t retDot = gSystem->Exec(runDot);
   if (gDebug < 4 && !retDot)
      gSystem->Unlink(Form("%s.dot", filename));

   if (!retDot && outMap) {
      std::ifstream inmap(Form("%s.map", filename));
      std::string line;
      std::getline(inmap, line);
      if (inmap && !inmap.eof()) {
         *outMap << "<map name=\"Map" << gSystem->BaseName(filename)
            << "\" id=\"Map" << gSystem->BaseName(filename) << "\">" << std::endl;
         while (inmap && !inmap.eof()) {
            if (line.compare(0, 6, "<area ") == 0) {
               size_t posEndTag = line.find('>');
               if (posEndTag != std::string::npos)
                  line.replace(posEndTag, 1, "/>");
            }
            *outMap << line << std::endl;
            std::getline(inmap, line);
         }
         *outMap << "</map>" << std::endl;
      }
      inmap.close();
      if (gDebug < 7)
         gSystem->Unlink(Form("%s.map", filename));
   }

   if (retDot) {
      Error("RunDot", "Error running %s!", runDot.Data());
      fHtml->SetFoundDot(kFALSE);
      return kFALSE;
   }

   return kTRUE;
}


//______________________________________________________________________________
void TDocOutput::WriteHtmlHeader(std::ostream& out, const char *titleNoSpecial,
                            const char* dir /*=""*/, TClass *cls /*=0*/,
                            const char* header)
{
// Write HTML header
//
// Internal method invoked by the overload

   std::ifstream addHeaderFile(header);

   if (!addHeaderFile.good()) {
      Warning("THtml::WriteHtmlHeader",
              "Can't open html header file %s\n", header);
      return;
   }

   TString declFileName;
   if (cls) fHtml->GetDeclFileName(cls, kFALSE, declFileName);
   TString implFileName;
   if (cls) fHtml->GetImplFileName(cls, kFALSE, implFileName);

   const TString& charset = GetHtml()->GetCharset();
   TDatime date;
   TString strDate(date.AsString());
   TString line;

   while (!addHeaderFile.eof()) {

      line.ReadLine(addHeaderFile, kFALSE);
      if (addHeaderFile.eof())
         break;

      if (line) {

         if (!cls && (
            line.Index("%CLASS%") != kNPOS ||
            line.Index("%INCFILE%") != kNPOS ||
            line.Index("%SRCFILE%") != kNPOS))
            continue; // skip class line for non-class files

         TString txt(line);

         txt.ReplaceAll("%TITLE%", titleNoSpecial);
         txt.ReplaceAll("%DATE%", strDate);
         txt.ReplaceAll("%RELDIR%", dir);
         txt.ReplaceAll("%CHARSET%", charset);

         if (cls) {
            txt.ReplaceAll("%CLASS%", cls->GetName());
            txt.ReplaceAll("%INCFILE%", declFileName);
            txt.ReplaceAll("%SRCFILE%", implFileName);
         }

         out << txt << std::endl;
      }
   }
}

//______________________________________________________________________________
void TDocOutput::WriteHtmlHeader(std::ostream& out, const char *title,
                            const char* dir /*=""*/, TClass *cls/*=0*/)
{
// Write HTML header
//
//
// Input: out   - output file stream
//        title - title for the HTML page
//        cls   - current class
//        dir   - relative directory to reach the top
//                ("" for html doc, "../" for src/*cxx.html etc)
//
// evaluates the Root.Html.Header setting:
// * if not set, the standard header is written. (ROOT)
// * if set, and ends with a "+", the standard header is written and this file
//   included afterwards. (ROOT, USER)
// * if set but doesn't end on "+" the file specified will be written instead
//   of the standard header (USER)
//
// Any occurrence of "%TITLE%" (without the quotation marks) in the user
// provided header file will be replaced by the value of this method's
// parameter "title" before written to the output file. %CLASS% is replaced by
// the class name, %INCFILE% by the header file name as given by
// TClass::GetDeclFileName() and %SRCFILE% by the source file name as given by
// TClass::GetImplFileName(). If the header is written for a non-class page,
// i.e. cls==0, lines containing %CLASS%, %INCFILE%, or %SRCFILE% will be
// skipped.

   TString userHeader = GetHtml()->GetHeader();
   TString noSpecialCharTitle(title);
   ReplaceSpecialChars(noSpecialCharTitle);

   Ssiz_t lenUserHeader = userHeader.Length();
   // standard header output if Root.Html.Header is not set, or it's set and it ends with a "+".
   Bool_t bothHeaders = lenUserHeader > 0 && userHeader[lenUserHeader - 1] == '+';
   if (lenUserHeader == 0 || bothHeaders) {
      TString header("header.html");
      gSystem->PrependPathName(fHtml->GetEtcDir(), header);
      WriteHtmlHeader(out, noSpecialCharTitle, dir, cls, header);
   }

   if (lenUserHeader != 0) {
      if (bothHeaders)
         userHeader.Remove(lenUserHeader - 1);
      WriteHtmlHeader(out, noSpecialCharTitle, dir, cls, userHeader);
   };
}

//______________________________________________________________________________
void TDocOutput::WriteHtmlFooter(std::ostream& out, const char* /*dir*/,
                                 const char* lastUpdate, const char* author,
                                 const char* copyright, const char* footer)
{
// Write HTML footer
//
// Internal method invoked by the overload

   static const char* templateSITags[TDocParser::kNumSourceInfos] = { "%UPDATE%", "%AUTHOR%", "%COPYRIGHT%", "%CHANGED%", "%GENERATED%"};

   TString today;
   TDatime dtToday;
   today.Form("%d-%02d-%02d %02d:%02d", dtToday.GetYear(), dtToday.GetMonth(), dtToday.GetDay(), dtToday.GetHour(), dtToday.GetMinute());

   TString datimeString;
   if (!lastUpdate || !lastUpdate[0]) {
      lastUpdate = today;
   }
   const char* siValues[TDocParser::kNumSourceInfos] = { lastUpdate, author, copyright, lastUpdate, today };

   std::ifstream addFooterFile(footer);

   if (!addFooterFile.good()) {
      Warning("THtml::WriteHtmlFooter",
              "Can't open html footer file %s\n", footer);
      return;
   }

   TString line;
   while (!addFooterFile.eof()) {

      line.ReadLine(addFooterFile, kFALSE);
      if (addFooterFile.eof())
         break;

      if (!line)
         continue;

      for (Int_t siTag = 0; siTag < (Int_t) TDocParser::kNumSourceInfos; ++siTag) {
         Ssiz_t siPos = line.Index(templateSITags[siTag]);
         if (siPos != kNPOS) {
            if (siValues[siTag] && siValues[siTag][0])
               line.Replace(siPos, strlen(templateSITags[siTag]), siValues[siTag]);
            else
               line = ""; // skip e.g. %AUTHOR% lines if no author is set
         }
      }

      out << line << std::endl;
   }

}

//______________________________________________________________________________
void TDocOutput::WriteHtmlFooter(std::ostream& out, const char *dir,
                            const char *lastUpdate, const char *author,
                            const char *copyright)
{
// Write HTML footer
//
//
// Input: out        - output file stream
//        dir        - usually equal to "" or "../", depends of
//                     current file directory position, i.e. if
//                     file is in the fHtml->GetOutputDir(), then dir will be ""
//        lastUpdate - last update string
//        author     - author's name
//        copyright  - copyright note
//
// Allows optional user provided footer to be written. Root.Html.Footer holds
// the file name for this footer. For details see THtml::WriteHtmlHeader (here,
// the "+" means the user's footer is written in front of Root's!) Occurences
// of %AUTHOR%, %CHANGED%, %GENERATED%, and %COPYRIGHT% in the user's file are replaced by
// their corresponding values (author, lastUpdate, today, and copyright) before
// written to out.
// If no author is set (author == "", e.g. for ClassIndex.html") skip the whole
// line of the footer template containing %AUTHOR%. Accordingly for %COPYRIGHT%.

   out << std::endl;

   TString userFooter = GetHtml()->GetFooter();

   if (userFooter.Length() != 0) {
      TString footer(userFooter);
      if (footer.EndsWith("+"))
         footer.Remove(footer.Length() - 1);
      WriteHtmlFooter(out, dir, lastUpdate, author, copyright, footer);
   };

   if (userFooter.Length() == 0 || userFooter.EndsWith("+")) {
      TString footer("footer.html");
      gSystem->PrependPathName(fHtml->GetEtcDir(), footer);
      WriteHtmlFooter(out, dir, lastUpdate, author, copyright, footer);
   }
}

//______________________________________________________________________________
void TDocOutput::WriteModuleLinks(std::ostream& out)
{
   // Create a div containing links to all topmost modules

   if (fHtml->GetListOfModules()->GetSize()) {
      out << "<div id=\"indxModules\"><h4>Modules</h4>" << std::endl;
      // find index chars
      fHtml->SortListOfModules();
      TIter iModule(fHtml->GetListOfModules());
      TModuleDocInfo* module = 0;
      while ((module = (TModuleDocInfo*) iModule())) {
         if (!module->GetName() || strchr(module->GetName(), '/'))
            continue;
         if (module->IsSelected()) {
            TString name(module->GetName());
            name.ToUpper();
            out << "<a href=\"" << name << "_Index.html\">"
                << name << "</a>" << std::endl;
         }
      }
      out<< "</div><br />" << std::endl;
   }
}

//______________________________________________________________________________
void TDocOutput::WriteLineNumbers(std::ostream& out, Long_t nLines, const TString& infileBase) const
{
   // Create a div containing the line numbers (for a source listing) 1 to nLines.
   // Create links to the source file's line number and anchors, such that one can
   // jump to SourceFile.cxx.html#27 (using the anchor), and one can copy and paste
   // the link into e.g. gdb to get the text "SourceFile.cxx:27".

   out << "<div id=\"linenums\">";
   for (Long_t i = 0; i < nLines; ++i) {
      // &nbsp; to force correct line height
      out << "<div class=\"ln\">&nbsp;<span class=\"lnfile\">" << infileBase
          << ":</span><a name=\"" << i + 1 << "\" href=\"#" << i + 1
          << "\" class=\"ln\">" << i + 1 << "</a></div>";
   }
   out << "</div>" << std::endl;

}

//______________________________________________________________________________
void TDocOutput::WriteModuleLinks(std::ostream& out, TModuleDocInfo* super)
{
   // Create a div containing links to all modules

   if (super->GetSub().GetSize()) {
      TString superName(super->GetName());
      superName.ToUpper();
      out << "<div id=\"indxModules\"><h4>" << superName << " Modules</h4>" << std::endl;
      // find index chars
      super->GetSub().Sort();
      TIter iModule(&super->GetSub());
      TModuleDocInfo* module = 0;
      while ((module = (TModuleDocInfo*) iModule())) {
         if (module->IsSelected()) {
            TString name(module->GetName());
            name.ToUpper();
            TString link(name);
            link.ReplaceAll("/", "_");
            Ssiz_t posSlash = name.Last('/');
            if (posSlash != kNPOS)
               name.Remove(0, posSlash + 1);
            out << "<a href=\"" << link << "_Index.html\">" << name << "</a>" << std::endl;
         }
      }
      out<< "</div><br />" << std::endl;
   }
}

//______________________________________________________________________________
void TDocOutput::WriteSearch(std::ostream& out)
{
   // Write a search link or a search box, based on THtml::GetSearchStemURL()
   // and THtml::GetSearchEngine(). The first one is preferred.

   // e.g. searchCmd = "http://www.google.com/search?q=%s+site%3A%u+-site%3A%u%2Fsrc%2F+-site%3A%u%2Fexamples%2F";
   const TString& searchCmd = GetHtml()->GetSearchStemURL();
   const TString& searchEngine = GetHtml()->GetSearchEngine();

   if (!searchCmd.Length() && !searchEngine.Length())
      return;

   if (searchCmd.Length()) {
      TUrl url(searchCmd);
      TString serverName(url.GetHost());
      if (serverName.Length()) {
         serverName.Prepend(" title=\"");
         serverName += "\" ";
      }
      // create search input
      out << "<script type=\"text/javascript\">" << std::endl
          << "function onSearch() {" << std::endl
          << "var s='" << searchCmd <<"';" << std::endl
          << "var ref=String(document.location.href).replace(/https?:\\/\\//,'').replace(/\\/[^\\/]*$/,'').replace(/\\//g,'%2F');" << std::endl
          << "window.location.href=s.replace(/%u/ig,ref).replace(/%s/ig,escape(document.searchform.t.value));" << std::endl
          << "return false;}" << std::endl
          << "</script>" << std::endl
          << "<form id=\"searchform\" name=\"searchform\" onsubmit=\"return onSearch()\" action=\"javascript:onSearch();\" method=\"post\">" << std::endl
          << "<input name=\"t\" size=\"30\" value=\"Search documentation...\" onfocus=\"if (document.searchform.t.value=='Search documentation...') document.searchform.t.value='';\"></input>" << std::endl
          << "<a id=\"searchlink\" " << serverName << " href=\"javascript:onSearch();\" onclick=\"return onSearch()\">Search</a></form>" << std::endl;
   } else if (searchEngine.Length())
      // create link to search engine page
      out << "<a class=\"descrheadentry\" href=\"" << searchEngine
          << "\">Search the Class Reference Guide</a>" << std::endl;
}


//______________________________________________________________________________
void TDocOutput::WriteLocation(std::ostream& out, TModuleDocInfo* module, const char* classname)
{
   // make a link to the description
   out << "<div class=\"location\">" << std::endl; // location
   const char *productName = fHtml->GetProductName();
   out << "<a class=\"locationlevel\" href=\"index.html\">" << productName << "</a>" << std::endl;

   if (module) {
      TString modulename(module->GetName());
      modulename.ToUpper();
      TString modulePart;
      TString modulePath;
      Ssiz_t pos = 0;
      while (modulename.Tokenize(modulePart, pos, "/")) {
         if (pos == kNPOS && !classname)
            // we are documenting the module itself, no need to link it:
            break;
         if (modulePath.Length()) modulePath += "_";
         modulePath += modulePart;
         out << " &#187; <a class=\"locationlevel\" href=\"./" << modulePath << "_Index.html\">" << modulePart << "</a>" << std::endl;
      }
   }

   TString entityName;
   if (classname) entityName = classname;
   else if (module) {
      entityName = module->GetName();
      Ssiz_t posSlash = entityName.Last('/');
      if (posSlash != kNPOS)
         entityName.Remove(0, posSlash + 1);
      entityName.ToUpper();
   }
   if (entityName.Length()) {
      out << " &#187; <a class=\"locationlevel\" href=\"#TopOfPage\">";
      ReplaceSpecialChars(out, entityName);
      out << "</a>" << std::endl;
   }
   out << "</div>" << std::endl; // location
}


//______________________________________________________________________________
void TDocOutput::WriteTopLinks(std::ostream& out, TModuleDocInfo* module, const char* classname,
                               Bool_t withLocation)
{
   // Write the first part of the links shown ontop of each doc page;
   // one <div> has to be closed by caller so additional items can still
   // be added.

   out << "<div id=\"toplinks\">" << std::endl;

   out << "<div class=\"descrhead\"><div class=\"descrheadcontent\">" << std::endl // descrhead line 1
      << "<span class=\"descrtitle\">Quick Links:</span>" << std::endl;

   // link to the user home page (if exist)
   const char* userHomePage = GetHtml()->GetHomepage();
   const char* productName = fHtml->GetProductName();
   if (!productName) {
      productName = "";
   } else if (!strcmp(productName, "ROOT")) {
      userHomePage = "";
   }
   if (userHomePage && *userHomePage)
      out << "<a class=\"descrheadentry\" href=\"" << userHomePage << "\">" << productName << "</a>" << std::endl;
   out << "<a class=\"descrheadentry\" href=\"http://root.cern.ch\">ROOT Homepage</a>" << std::endl
      << "<a class=\"descrheadentry\" href=\"./ClassIndex.html\">Class Index</a>" << std::endl
      << "<a class=\"descrheadentry\" href=\"./ClassHierarchy.html\">Class Hierarchy</a></div>" << std::endl;
   WriteSearch(out);
   out << "</div>" << std::endl; // descrhead, line 1

   if (withLocation) {
      out << "</div>" << std::endl; //toplinks
      WriteLocation(out, module, classname); // descrhead line 2
   }
   // else {
   //    Closed by caller!
   //    out << "</div>" << std::endl; // toplinks
   // }

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