// @(#)root/table:$Id$
// Author: Valery Fine(fine@bnl.gov)   03/07/98

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


////////////////////////////////////////////////////////////////////////////
//                                                                        //
// TTable                                                                 //
//                                                                        //
// Wraps the array of the plain C-structures (one C-structure per element)//
//                                                                        //
// class TTable provides the automatic schema evolution for               //
// the derived "table" classes saved with ROOT format.                    //
//                                                                        //
// "Automatic Schema evolution" provides:                                 //
//   -  skipping data-member if it is not present for the current         //
//      implementation of the "table" but was present at the time the     //
//      table was written;                                                //
//   -  assign a default value ZERO for the brand-new data-members,       //
//      those were not in the structure when the object was written but   //
//      present now;                                                      //
//   -  trace propely any change in the order of the data-members         //
//                                                                        //
// To enjoy this class one has to derive one's own custom class:          //
//                                                                        //
// St_dst_track_Table.h:                                                  //
// ---------------------                                                  //
//  #ifndef STAF_St_dst_track_Table                                       //
//  #define STAF_St_dst_track_Table                                       //
//                                                                        //
//  #include "TTable.h"                                                   //
//                                                                        //
// // #include "dst_track.h"  the C-structure defintion may be kept       //
//                            separately                                  //
//  typedef struct dst_track_st {                                         //
//     float r0;             /* radius at start (cm). See also comments*/
//     float phi0;           /* azimuthal angle at start (deg)         */
//     float z0;             /* z-coord. at start (cm)                 */
//     float psi;            /* azimuthal angle of pT vector (deg)     */
//     float tanl;           /* tan(dip) =pz/pt at start               */
//     float invpt;          /* 1/pt at start (GeV/c)^(-1)             */
//     float curvature;      /* Track curvature (1/cm)                 */
//     float covar[15];      /* full covariance matrix                 */
//     float chisq[2];       /* Chi-square per degree of freedom       */
//     float x_first[3];     /* coord. of first measured point (cm)    */
//     float x_last[3];      /* coord. of last measured point (cm)     */
//     float length;         /* from first to last point (cm)          */
//     float impact;         /* primary vertex (cm)                    */
//     unsigned long map[2]; /* extrap. info. (see preceding comments)*/
//     int id;               /* Primary key (see comments)             */
//     int iflag;            /* bitmask quality info. (see comments)   */
//     int det_id;           /* Detector id information                */
//     int method;           /* Track finding/fitting method, packed   */
//     int pid;              /* Geant particle ID for assumed mass     */
//     int n_point;          /* SVT, TPC, FTPC component #s are packed */
//     int n_max_point;      /* SVT, TPC, FTPC component #s are packed */
//     int n_fit_point;      /* SVT, TPC, FTPC component #s are packed */
//     int icharge;          /* Particle charge in units of |e|        */
//     int id_start_vertex;  /* final fit and primary track candidates */
//  } DST_TRACK_ST;                                                       //
//                                                                        //
//  class St_dst_track : public TTable                                    //
//  {                                                                     //
//   public:                                                              //
//     ClassDefTable(St_dst_track,dst_track_st)                           //
//     ClassDef(St_dst_track,2) //C++ wrapper for <dst_track> StAF table  //
//  };                                                                    //
//  #endif                                                                //
// ---------------------                                                  //
//                                                                        //
//  where the CPP macro defines several convinient methods for the        //
//  "table" class (see: $ROOTSYS/table/inc/Ttypes.h for details:          //
//                                                                        //
//  #define ClassDefTable(className,structName)
//    protected:
//       static TTableDescriptor *fgColDescriptors;
//       virtual TTableDescriptor *GetDescriptorPointer() const { return fgColDescriptors;}
//       virtual void SetDescriptorPointer(TTableDescriptor *list) const { fgColDescriptors = list;}
//    public:
//      typedef structName* iterator;
//      className() : TTable(_QUOTE_(className),sizeof(structName))    {SetType(_QUOTE_(structName));}
//      className(const char *name) : TTable(name,sizeof(structName)) {SetType(_QUOTE_(structName));}
//      className(Int_t n) : TTable(_QUOTE_(className),n,sizeof(structName)) {SetType(_QUOTE_(structName));}
//      className(const char *name,Int_t n) : TTable(name,n,sizeof(structName)) {SetType(_QUOTE_(structName));}
//      structName *GetTable(Int_t i=0) const { return ((structName *)GetArray())+i;}
//      structName &operator[](Int_t i){ assert(i>=0 && i < GetNRows()); return *GetTable(i); }
//      const structName &operator[](Int_t i) const { assert(i>=0 && i < GetNRows()); return *((const structName *)(GetTable(i))); }
//      structName *begin() const  {                      return GetNRows()? GetTable(0):0;}
//      structName *end()   const  {Int_t i = GetNRows(); return          i? GetTable(i):0;}
//                                                                        //
//  The class implementation file may 2 lines and look as follows:        //
//  (for the example above):                                              //
//                                                                        //
//  St_dst_track_Table.cxx:                                               //
//  -----------------------                                               //
//       #include "St_dst_track_Table.h"                                  //
//       TableClassImpl(St_dst_track, dst_track_st)                       //
//  -----------------------                                               //
//  LinkDef.h                                                             //
//  -----------------------                                               //
//  To provide ROOT I/O for this class TWO CINT dictonary entries         //
//  should be defined with your custom LinkDef.h file                     //
//     1. First entry (as usually) for the class derived from TTable      //
//        for example:                                                    //
// #pragma C++ class St_dst_track                                         //
//     2. Second entry for the C-structure wrapped into the class.        //
//         Since C-structuire is not derived from TObject it must be      //
//         properly defined as "foreign" ROOT class                       //
//    #pragma C++ class dst_track_st+;                                    //
//  -----------------------                                               //
// meta-variables i$ and n$ introduced                                    //
// where "i$" stands for the current row index                            //
//       "n$" stands for the total number of rows                         //
// meta-variable can be used along the normal                             //
// table column names in the expressions (see for example                 //
// method TTable::Draw                                                    //
//                                                                        //
////////////////////////////////////////////////////////////////////////////

#include <assert.h>

#ifdef WIN32
# include <float.h>
#endif

#include "RConfigure.h"

//#if ROOT_VERSION_CODE >= ROOT_VERSION(3,03,5)
#include "Riosfwd.h"
#include "Riostream.h"
//#include <iomanip.h>

// #endif

#include "TROOT.h"
#include "TBaseClass.h"
#include "TSystem.h"
#include "TBuffer.h"
#include "TMath.h"
#include "TClass.h"
#include "TBrowser.h"
#include "TString.h"
#include "TInterpreter.h"
#include "TDataSetIter.h"
#include "TTable.h"
#include "TTableDescriptor.h"
#include "TColumnView.h"

#include "TGaxis.h"
#include "TH1.h"
#include "TH2.h"
#include "TProfile.h"
#include "TVirtualPad.h"
#include "TEventList.h"
#include "TPolyMarker.h"
#include "TView.h"
#include "TGaxis.h"
#include "TPolyMarker3D.h"

#include "THLimitsFinder.h"

#include "TTableMap.h"

static TH1 *gCurrentTableHist = 0;

static const char *gDtorName = "dtor";
static   Int_t         gNbins[4] = {100,100,100,100};     //Number of bins per dimension
static   Float_t       gVmin[4]  = {0,0,0,0};             //Minima of varexp columns
static   Float_t       gVmax[4]  = {20,20,20,20};         //Maxima of varexp columns

const char *TTable::fgTypeName[] = {
   "NAN", "float", "int", "long", "short", "double",
   "unsigned int", "unsigned long","unsigned short",
   "unsigned char", "char", "Ptr_t"
};

//______________________________________________________________________________
static void ArrayLayout(UInt_t *layout,const UInt_t *size, Int_t dim)
{
  //
  // ArrayLayout - calculates the array layout recursively
  //
  // Input:
  // -----
  // dim   - dimension of the targeted array
  // size  - the max index for each dimension
  //
  // Output:
  // ------
  // layout - the "start index" for each dimension of an array
  //

   if (dim && layout && size) {
      if (++layout[dim-1] >= size[dim-1]) {
         layout[dim-1] = 0;
         dim--;
         ArrayLayout(layout,size, dim);
      }
   }
}

ClassImp(TTable)

//______________________________________________________________________________
TTableDescriptor *TTable::GetTableDescriptors() const {
 // protected: create a new TTableDescriptor descriptor for this table
   assert(0);
   return new TTableDescriptor(this);
}

//______________________________________________________________________________
void TTable::AsString(void *buf, EColumnType type, Int_t width,std::ostream &out) const
{
  //
  // AsString represents the value provided via "void *b" with type defined
  //          by "name"
  //
  //   void *buf  - the pointer to the value to be printed out.
  //        type  - the basic data type for the value above
  //       width  - the number of psotion to be used to print the value out
  //
   int prevPrec = out.precision();
   const std::ios_base::fmtflags prevFmt = out.flags();

   switch (type) {
      case kFloat:
         out << std::dec  << std::setw(width) << std::setprecision(width-3) << *(float *)buf;
         break;
      case kInt:
         out << std::dec  <<  std::setw(width) << *(int *)buf;
         break;
      case kLong:
         out << std::dec  << std::setw(width) << *(Long_t *)buf;
         break;
      case kShort:
         out << std::dec  << std::setw(width) << *(short *)buf;
         break;
      case kDouble:
         out << std::dec  << std::setw(width) << std::setprecision(width-3) << *(double *)buf;
         break;
      case kUInt:
         out << std::dec  << std::setw(width) << *(unsigned int *)buf;
         break;
      case kULong:
         out << std::dec  << std::setw(width) << *(ULong_t *)buf;
         break;
      case kUShort:
         out  << std::setw(width) << "0x" << std::hex << *(unsigned short *)buf;
         break;
      case kUChar:
         out  << std::setw(width) << "0x" << std::hex << int(*(unsigned char *)buf);
         break;
      case kChar:
         out << std::setw(width) << *(char *)buf;
         break;
      case kBool:
         out << std::setw(width) << *(Bool_t *)buf;
         break;
      case kPtr:
         out << "->" << std::setw(width) << *(void **)buf;
         break;
      default:
         out << "\"NaN\"";
         break;
   };
   out.precision(prevPrec);
   out.setf(prevFmt);
}

//________________________________________________________________________
const char *TTable::GetTypeName(TTable::EColumnType type)
{
   //return table type name
   return  fgTypeName[type];
}

//________________________________________________________________________
TTable::EColumnType TTable::GetTypeId(const char *typeName)
{
   // return the Id of the C basic type by given name
   // return kNAN if the name provided fits no knwn basic name.
   //
   Int_t allTypes = sizeof(fgTypeName)/sizeof(const char *);
   for (int i = 0; i < allTypes; i++)
   if (!strcmp(fgTypeName[i],typeName)) return EColumnType(i);
   return kNAN;
}

//______________________________________________________________________________
const void *TTable::At(Int_t i) const
{
   // Returns a pointer to the i-th row of the table
   if (!BoundsOk("TTable::At", i)) {
       Warning("TTable::At","%s.%s",GetName(),GetType());
      i = 0;
   }
   return (const void *)(fTable+i*fSize);
}

//______________________________________________________________________________
Int_t TTable::CopyRows(const TTable *srcTable, Long_t srcRow, Long_t dstRow, Long_t nRows, Bool_t expand)
{
 // CopyRows copies nRows from starting from the srcRow of srcTable
 // to the dstRow in this table upto nRows or by the end of this table.
 //
 // This table if automaticaly increased if expand = kTRUE.
 // The old values of this table rows are to be destroyed and
 // replaced with the new ones.
 //
 // PARAMETERS:
 //   srcTable - a pointer to the table "donor"
 //   srcRow   - the index of the first row of the table donor to copy from
 //   dstRow   - the index of the first row of this table to copy to
 //   nRows    - the total number of rows to be copied. This table will be expanded
 //              as needed if expand = kTRUE (it is kFALSE "by default")
 //          = 0 to copy ALL remain rows from the srcTable.
 //   expand   - flag whether this table should reallocated if needed.
 //
 // RETURN:
 //          the number of the rows been copied

   assert(!TestBit(kIsNotOwn));
   if (!(srcTable && srcTable->GetNRows()) || srcRow > srcTable->GetNRows()-1   )   return 0;
   if (strcmp(GetType(),srcTable->GetType())) {
      // check this table current capacity
      if (!nRows) nRows = srcTable->GetNRows();
      Long_t tSize = GetTableSize();
      Long_t extraRows = (tSize - dstRow) - nRows;
      if (extraRows < 0) {
         if (expand) {
            ReAllocate(tSize - extraRows);
            extraRows = 0;
         }
         nRows += extraRows;
      }
      if (dstRow+nRows > GetNRows()) SetNRows(dstRow+nRows);
      ::memmove((*this)[dstRow],(*srcTable)[srcRow],(size_t)GetRowSize()*nRows);
      return nRows;
   } else
      Error("CopyRows",
           "This table is <%s> but the src table has a wrong type <%s>",GetType()
           ,srcTable->GetType());
   return 0;
}
//______________________________________________________________________________
void TTable::DeleteRows(Long_t indx, UInt_t nRows)
{
  // Delete one or several rows from the table
  //
  //  Int_t indx  - index of the first row to be deleted
  //  Int_t nRows - the total number of rows to be deleted
  //              = 1 "by default
   if (CopyRows(this, indx+nRows, indx, GetNRows()-indx-nRows))
      SetUsedRows(GetNRows() - nRows);
}
//______________________________________________________________________________
TH1  *TTable::Draw(TCut varexp, TCut selection, Option_t *option, Int_t nentries, Int_t firstentry)
{
//*-*-*-*-*-*-*-*-*-*-*Draw expression varexp for specified entries-*-*-*-*-*
//*-*                  ===========================================
//
//   This function accepts TCut objects as arguments.
//   Useful to use the string operator +
//         example:
//            table.Draw("x",cut1+cut2+cut3);
//
//   TCutG object with "CUTG" name can be created via the graphics editor.
//

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

//______________________________________________________________________________
TH1 *TTable::Draw(const char *varexp00, const char *selection, Option_t *option,Int_t nentries, Int_t firstentry)
{
//*-*-*-*-*-*-*-*-*-*-*Draw expression varexp for specified entries-*-*-*-*-*
//*-*                  ===========================================
//
//  varexp is an expression of the general form e1:e2:e3
//    where e1,etc is a C++ expression referencing a combination of the TTable columns
//          One can use two extra meta variable "i$" and "n$" along with the table
//          column names.
//          i$ is to involve the current row number
//          n$ refers the total num,ber of rows of this table provided by TTable::GetNRows()
//
//  Example:
//     varexp = x     simplest case: draw a 1-Dim distribution of column named x
//            = sqrt(x)            : draw distribution of sqrt(x)
//            = x*y/z
//            = y:sqrt(x) 2-Dim dsitribution of y versus sqrt(x)
//            = i$:sqrt(x) 2-Dim dsitribution of i versus sqrt(x[i])
//            = phep[0]:sqrt(phep[3]) 2-Dim dsitribution of phep[0] versus sqrt(phep[3])
//
//  Note that the variables e1, e2 or e3 may contain a boolean expression as well.
//  example, if e1= x*(y<0), the value histogrammed will be x if y<0
//  and will be 0 otherwise.
//
//  selection is a C++ expression with a combination of the columns.
//  The value corresponding to the selection expression is used as a weight
//  to fill the histogram.
//  If the expression includes only boolean operations, the result
//  is 0 or 1. If the result is 0, the histogram is not filled.
//  In general, the expression may be of the form:
//
//      value*(boolean expression)
//
//  if boolean expression is true, the histogram is filled with
//  a weight = value.
//  Examples:
//      selection1 = "x<y && sqrt(z)>3.2 && 6 < i$ && i$ < n$"
//      selection2 = "(x+y)*(sqrt(z)>3.2"
//      selection3 = "signal*(log(signal)>1.2)"
//  selection1 returns a weigth = 0 or 1
//  selection2 returns a weight = x+y if sqrt(z)>3.2
//             returns a weight = 0 otherwise.
//  selection3 returns a weight = signal if log(signal)>1.2
//
//  option is the drawing option
//      see TH1::Draw for the list of all drawing options.
//      If option contains the string "goff", no graphics is generated.
//
//  nentries is the number of entries to process (default is all)
//  first is the first entry to process (default is 0)
//
//     Saving the result of Draw to an histogram
//     =========================================
//  By default the temporary histogram created is called htemp.
//  If varexp0 contains >>hnew (following the variable(s) name(s),
//  the new histogram created is called hnew and it is kept in the current
//  directory.
//  Example:
//    tree.Draw("sqrt(x)>>hsqrt","y>0")
//    will draw sqrt(x) and save the histogram as "hsqrt" in the current
//    directory.
//
//  By default, the specified histogram is reset.
//  To continue to append data to an existing histogram, use "+" in front
//  of the histogram name;
//    table.Draw("sqrt(x)>>+hsqrt","y>0")
//      will not reset hsqrt, but will continue filling.
//
//     Making a Profile histogram
//     ==========================
//  In case of a 2-Dim expression, one can generate a TProfile histogram
//  instead of a TH2F histogram by specyfying option=prof or option=profs.
//  The option=prof is automatically selected in case of y:x>>pf
//  where pf is an existing TProfile histogram.
//
//     Saving the result of Draw to a TEventList
//     =========================================
//  TTable::Draw can be used to fill a TEventList object (list of entry numbers)
//  instead of histogramming one variable.
//  If varexp0 has the form >>elist , a TEventList object named "elist"
//  is created in the current directory. elist will contain the list
//  of entry numbers satisfying the current selection.
//  Example:
//    tree.Draw(">>yplus","y>0")
//    will create a TEventList object named "yplus" in the current directory.
//    In an interactive session, one can type (after TTable::Draw)
//       yplus.Print("all")
//    to print the list of entry numbers in the list.
//
//  By default, the specified entry list is reset.
//  To continue to append data to an existing list, use "+" in front
//  of the list name;
//    table.Draw(">>+yplus","y>0")
//      will not reset yplus, but will enter the selected entries at the end
//      of the existing list.
//

   if (GetNRows() == 0 || varexp00 == 0 || varexp00[0]==0) return 0;
   TString  opt;
//   char *hdefault = (char *)"htemp";
   const char *hdefault = "htemp";
   Int_t i,j,action;
   Int_t hkeep = 0;
   opt = option;
   opt.ToLower();
   char *varexp0 = StrDup(varexp00);
   char *hname = strstr(varexp0,">>");
   TH1 *oldh1 = 0;
   TEventList *elist = 0;
   Bool_t profile = kFALSE;

   gCurrentTableHist = 0;
   if (hname) {
      *hname  = 0;
      hname += 2;
      hkeep  = 1;
      i = strcspn(varexp0,">>");
      Bool_t hnameplus = kFALSE;
      while (*hname == ' ') hname++;
      if (*hname == '+') {
         hnameplus = kTRUE;
         hname++;
         while (*hname == ' ') hname++;
         j = strlen(hname)-1;
         while (j) {
            if (hname[j] != ' ') break;
            hname[j] = 0;
            j--;
         }
      }
      if (i) {
         oldh1 = (TH1*)gDirectory->Get(hname);
         if (oldh1 && !hnameplus) oldh1->Reset();
      } else {
         elist = (TEventList*)gDirectory->Get(hname);
         if (!elist) {
            elist = new TEventList(hname,selection,1000,0);
         }
         if (elist && !hnameplus) elist->Reset();
      }
   }
   if (!hname || *hname==0) {
      hkeep  = 0;
      if (gDirectory) {
         oldh1 = (TH1*)gDirectory->Get(hdefault);
         if (oldh1 ) { oldh1->Delete(); oldh1 = 0;}
      }
   }

   // Look for colons
   const Char_t *expressions[] ={varexp0,0,0,0,selection};
   Int_t maxExpressions = sizeof(expressions)/sizeof(Char_t *);
   Char_t *nextColon    = varexp0;
   Int_t colIndex       = 1;
   while ((nextColon = strchr(nextColon,':')) && ( colIndex < maxExpressions - 1 ) ) {
      *nextColon = 0;
      nextColon++;
      expressions[colIndex] = nextColon;
      colIndex++;
   }

   expressions[colIndex] = selection;


//--------------------------------------------------
   Printf(" Draw %s for <%s>\n", varexp00, selection);
   Char_t *exprFileName = MakeExpression(expressions,colIndex+1);
   if (!exprFileName) {
      delete [] varexp0;
      return 0;
   }

//--------------------------------------------------
//   if (!fVar1 && !elist) return 0;

//*-*- In case oldh1 exists, check dimensionality
   Int_t dimension = colIndex;

   TString title = expressions[0];
   for (i=1;i<colIndex;i++) {
      title += ":";
      title += expressions[i];
   }
   Int_t nsel = strlen(selection);
   if (nsel > 1) {
      if (nsel < 80-title.Length()) {
         title += "{";
         title += selection;
         title += "}";
      } else
         title += "{...}";
   }

   const Char_t *htitle = title.Data();

   if (oldh1) {
      Int_t mustdelete = 0;
      if (oldh1->InheritsFrom(TProfile::Class())) profile = kTRUE;
      if (opt.Contains("prof")) {
         if (!profile) mustdelete = 1;
      } else {
         if (oldh1->GetDimension() != dimension) mustdelete = 1;
      }
      if (mustdelete) {
         Warning("Draw","Deleting old histogram with different dimensions");
         delete oldh1; oldh1 = 0;
      }
   }
//*-*- Create a default canvas if none exists
   if (!gPad && !opt.Contains("goff") && dimension > 0) {
      gROOT->MakeDefCanvas();
   }
//*-*- 1-D distribution
   if (dimension == 1) {
      action = 1;
      if (!oldh1) {
         gNbins[0] = 100;
         if (gPad && opt.Contains("same")) {
            TH1 *oldhtemp = (TH1*)gPad->FindObject(hdefault);
            if (oldhtemp) {
               gNbins[0] = oldhtemp->GetXaxis()->GetNbins();
               gVmin[0]  = oldhtemp->GetXaxis()->GetXmin();
               gVmax[0]  = oldhtemp->GetXaxis()->GetXmax();
            } else {
               gVmin[0]  = gPad->GetUxmin();
               gVmax[0]  = gPad->GetUxmax();
            }
         } else {
            action = -1;
         }
      }
      TH1F *h1;
      if (oldh1) {
         h1 = (TH1F*)oldh1;
         gNbins[0] = h1->GetXaxis()->GetNbins();  // for proofserv
      } else {
         h1 = new TH1F(hname,htitle,gNbins[0],gVmin[0],gVmax[0]);
         if (!hkeep) {
            h1->SetBit(kCanDelete);
            h1->SetDirectory(0);
         }
         if (opt.Length() && opt[0] == 'e') h1->Sumw2();
      }

      EntryLoop(exprFileName,action, h1, nentries, firstentry, option);

//    if (!fDraw && !opt.Contains("goff")) h1->Draw(option);
      if (!opt.Contains("goff")) h1->Draw(option);

//*-*- 2-D distribution
   } else if (dimension == 2) {
      action = 2;
      if (!opt.Contains("same") && gPad)  gPad->Clear();
      if (!oldh1 || !opt.Contains("same")) {
         gNbins[0] = 40;
         gNbins[1] = 40;
         if (opt.Contains("prof")) gNbins[1] = 100;
         if (opt.Contains("same")) {
            TH1 *oldhtemp = (TH1*)gPad->FindObject(hdefault);
            if (oldhtemp) {
               gNbins[1] = oldhtemp->GetXaxis()->GetNbins();
               gVmin[1]  = oldhtemp->GetXaxis()->GetXmin();
               gVmax[1]  = oldhtemp->GetXaxis()->GetXmax();
               gNbins[0] = oldhtemp->GetYaxis()->GetNbins();
               gVmin[0]  = oldhtemp->GetYaxis()->GetXmin();
               gVmax[0]  = oldhtemp->GetYaxis()->GetXmax();
            } else {
               gNbins[1] = 40;
               gVmin[1]  = gPad->GetUxmin();
               gVmax[1]  = gPad->GetUxmax();
               gNbins[0] = 40;
               gVmin[0]  = gPad->GetUymin();
               gVmax[0]  = gPad->GetUymax();
            }
         } else {
            action = -2;
         }
      }
      if (profile || opt.Contains("prof")) {
         TProfile *hp;
         if (oldh1) {
            action = 4;
            hp = (TProfile*)oldh1;
         } else {
            if (action < 0) action = -4;
            if (opt.Contains("profs"))
               hp = new TProfile(hname,htitle,gNbins[1],gVmin[1], gVmax[1],"s");
            else
               hp = new TProfile(hname,htitle,gNbins[1],gVmin[1], gVmax[1],"");
            if (!hkeep) {
               hp->SetBit(kCanDelete);
               hp->SetDirectory(0);
            }
         }

         EntryLoop(exprFileName,action,hp,nentries, firstentry, option);

         if (!opt.Contains("goff")) hp->Draw(option);
      } else {
         TH2F *h2;
         if (oldh1) {
            h2 = (TH2F*)oldh1;
         } else {
            h2 = new TH2F(hname,htitle,gNbins[1],gVmin[1], gVmax[1], gNbins[0], gVmin[0], gVmax[0]);
            if (!hkeep) {
               const Int_t kNoStats = BIT(9);
               h2->SetBit(kCanDelete);
               h2->SetBit(kNoStats);
               h2->SetDirectory(0);
            }
         }
         Int_t noscat = strlen(option);
         if (opt.Contains("same")) noscat -= 4;
         if (noscat) {
            EntryLoop(exprFileName,action,h2,nentries, firstentry, option);
 //           if (!fDraw && !opt.Contains("goff")) h2->Draw(option);
            if (!opt.Contains("goff")) h2->Draw(option);
         } else {
            action = 12;
            if (!oldh1 && !opt.Contains("same")) action = -12;
            EntryLoop(exprFileName,action,h2,nentries, firstentry, option);
//            if (oldh1 && !fDraw && !opt.Contains("goff")) h2->Draw(option);
            if (oldh1 && !opt.Contains("goff")) h2->Draw(option);
         }
      }

//*-*- 3-D distribution
   } else if (dimension == 3) {
      action = 13;
      if (!opt.Contains("same")) action = -13;
      EntryLoop(exprFileName,action,0,nentries, firstentry, option);

//*-* an Event List
   //} else if (elist) {
   //   action = 5;
//      Int_t oldEstimate = fEstimate;
//      SetEstimate(1);
   //   EntryLoop(exprFileName,action,elist,nentries, firstentry, option);
//      SetEstimate(oldEstimate);
   }
   delete [] exprFileName;
   delete [] varexp0;
   return gCurrentTableHist;
}

//______________________________________________________________________________
static void FindGoodLimits(Int_t nbins, Int_t &newbins, Float_t &xmin, Float_t &xmax)
{
//*-*-*-*-*-*-*-*-*Find reasonable bin values*-*-*-*-*-*-*-*-*-*-*-*-*-*-*
//*-*              ==========================
//*-*  This mathod is a straight copy of void TTree::FindGoodLimits method
//*-*

   Double_t binlow=0,binhigh=0,binwidth=0;
   Int_t n;
   Double_t dx = 0.1*(xmax-xmin);
   Double_t umin = xmin - dx;
   Double_t umax = xmax + dx;
   if (umin < 0 && xmin >= 0) umin = 0;
   if (umax > 0 && xmax <= 0) umax = 0;

#if ROOT_VERSION_CODE >= ROOT_VERSION(3,03,5)
   THLimitsFinder::Optimize(umin,umax,nbins,binlow,binhigh,n,binwidth,"");
#else
   TGaxis::Optimize(umin,umax,nbins,binlow,binhigh,n,binwidth,"");
#endif

   if (binwidth <= 0 || binwidth > 1.e+39) {
      xmin = -1;
      xmax = 1;
   } else {
      xmin    = binlow;
      xmax    = binhigh;
   }

   newbins = nbins;
}

//______________________________________________________________________________
Bool_t TTable::EntryLoop(const Char_t *exprFileName,Int_t &action, TObject *obj
                          ,Int_t nentries, Int_t firstentry, Option_t *option)
{
 //
 // EntryLoop creates a CINT bytecode to evaluate the given expressions for
 // all table rows in loop and fill the appropriated histograms.
 //
 // Solution for Byte code
 // From: Masaharu Goto <MXJ02154@nifty.ne.jp>
 // To: <fine@bnl.gov>
 // Cc: <rootdev@hpsalo.cern.ch>
 // Sent: 13-th august 1999 year  23:01
 //
 //  action =  1  Fill 1-D histogram obj
 //         =  2  Fill 2-D histogram obj
 //         =  3  Fill 3-D histogram obj
 //         =  4  Fill Profile histogram obj
 //         =  5  Fill a TEventlist
 //         = 11  Estimate Limits
 //         = 12  Fill 2-D PolyMarker obj
 //         = 13  Fill 3-D PolyMarker obj
 //  action < 0   Evaluate Limits for case abs(action)
 //
 //  Load file
   Double_t rmin[3],rmax[3];
   if (gInterpreter->LoadFile((Char_t *)exprFileName) < 0) {
      Error("EntryLoop","Error: loading file %s",exprFileName);
      return kFALSE; // can not load file
   }

   // Float_t  Selection(Float_t *results[], void *address[], int& i$, int n$)
   //   where  i$ - meta variable to set current row index
   //          n$ - meta variable to set the total table size
   const Char_t *funcName = "SelectionQWERTY";
#ifdef BYTECODE
   const Char_t *argtypes = "Float_t *,float **, int&, int& ";
   Long_t offset;
   G__ClassInfo globals;
   G__MethodInfo func = globals.GetMethod(funcName,argtypes,&offset);

   // Compile bytecode
   struct G__bytecodefunc *pbc = func.GetBytecode();
   if(!pbc) {
      Error("EntryLoop","Bytecode compilation %s",funcName);
      G__unloadfile((Char_t *)exprFileName);
      return kFALSE; // can not get bytecode
   }
#endif
   // Prepare callfunc object
   int i;
   int nRows =  GetNRows();
   TTableDescriptor    *tabsDsc   = GetRowDescriptors();
   tableDescriptor_st  *descTable = tabsDsc->GetTable();
   Float_t  results[]    = {1,1,1,1,1};
   Char_t **addressArray = (Char_t **)new ULong_t[tabsDsc->GetNRows()];
   Char_t *thisTable     = (Char_t *)GetArray();
   const Char_t *argtypes = "Float_t *,float **, int&, int& ";
   Long_t offset;
   ClassInfo_t *globals = gInterpreter->ClassInfo_Factory();
   CallFunc_t *callfunc = gInterpreter->CallFunc_Factory();
   gInterpreter->CallFunc_SetFunc(callfunc,globals,funcName,argtypes,&offset);

   gInterpreter->CallFunc_SetArg(callfunc,(Long_t)(&results[0]));   // give 'Float_t *results[5]'     as 1st argument
   gInterpreter->CallFunc_SetArg(callfunc,(Long_t)(addressArray));  // give 'void    *addressArray[]' as 2nd argument
   gInterpreter->CallFunc_SetArg(callfunc,(Long_t)(&i));            // give 'int& i$'                 as 3nd argument
   gInterpreter->CallFunc_SetArg(callfunc,(Long_t)(&nRows));        // give 'int& n$= nRows           as 4th argument

   // Call bytecode in loop

#define CALLMETHOD gInterpreter->CallFunc_Exec(callfunc,0);

#define TAKEACTION_BEGIN                                                                    \
            descTable = tabsDsc->GetTable();                                                \
            for (i=0; i < tabsDsc->GetNRows(); i++,descTable++ )                            \
               addressArray[i] = addressEntry + descTable->fOffset;                         \
            for(i=firstentry;i<lastEntry;i++) {                                             \
            CALLMETHOD

#define TAKEACTION_END  for (int j=0; j < tabsDsc->GetNRows(); j++ ) addressArray[j] += rSize;}


   if (firstentry < nRows ) {
      Long_t rSize         = GetRowSize();
      Char_t *addressEntry = thisTable + rSize*firstentry;
      Int_t lastEntry = TMath::Min(UInt_t(firstentry+nentries),UInt_t(nRows));
      if (action < 0) {
         gVmin[0] = gVmin[1] = gVmin[2] = 1e30;
         gVmax[0] = gVmax[1] = gVmax[2] = -gVmin[0];
      }
      Int_t nchans = 0;
      switch ( action ) {
         case -1: {
            TAKEACTION_BEGIN
            if (results[1]) {
               if (gVmin[0] > results[0]) gVmin[0] = results[0];
               if (gVmax[0] < results[0]) gVmax[0] = results[0];
            }
            TAKEACTION_END

            nchans = gNbins[0];
            if (gVmin[0] >= gVmax[0]) { gVmin[0] -= 1; gVmax[0] += 1;}
            FindGoodLimits(nchans,gNbins[0],gVmin[0],gVmax[0]);
            ((TH1 *)obj)->SetBins(gNbins[0],gVmin[0],gVmax[0]);
         }
         // Intentional fall though
         case  1:
            TAKEACTION_BEGIN
            if (results[1]) ((TH1 *)obj)->Fill(Axis_t(results[0]),Stat_t(results[1]));
            TAKEACTION_END
            gCurrentTableHist = ((TH1 *)obj);
            break;
         case  -2:
            TAKEACTION_BEGIN
            if (results[2]) {
               if (gVmin[0] > results[1]) gVmin[0] = results[1];
               if (gVmax[0] < results[1]) gVmax[0] = results[1];
               if (gVmin[1] > results[0]) gVmin[1] = results[0];
               if (gVmax[1] < results[0]) gVmax[1] = results[0];
            }
            TAKEACTION_END
            nchans = gNbins[0];
            if (gVmin[0] >= gVmax[0]) { gVmin[0] -= 1; gVmax[0] += 1;}
            FindGoodLimits(nchans,gNbins[0],gVmin[0],gVmax[0]);
            if (gVmin[1] >= gVmax[1]) { gVmin[1] -= 1; gVmax[1] += 1;}
            FindGoodLimits(nchans,gNbins[1],gVmin[1],gVmax[1]);
            ((TH1*)obj)->SetBins(gNbins[1],gVmin[1],gVmax[1],gNbins[0],gVmin[0],gVmax[0]);
            // Intentional fall though
         case   2:
            if (obj->IsA() == TH2F::Class()) {
               TAKEACTION_BEGIN
               if (results[2]) ((TH2F*)obj)->Fill(Axis_t(results[0]),Axis_t(results[1]),Stat_t(results[2]));
               TAKEACTION_END
            } else if (obj->IsA() == TH2S::Class()) {
               TAKEACTION_BEGIN
               if (results[2]) ((TH2S*)obj)->Fill(Axis_t(results[0]),Axis_t(results[1]),Stat_t(results[2]));
               TAKEACTION_END
            } else if (obj->IsA() == TH2C::Class()) {
               TAKEACTION_BEGIN
               if (results[2]) ((TH2C*)obj)->Fill(Axis_t(results[0]),Axis_t(results[1]),Stat_t(results[2]));
               TAKEACTION_END
            } else if (obj->IsA() == TH2D::Class()) {
               TAKEACTION_BEGIN
               if (results[2]) ((TH2D*)obj)->Fill(Axis_t(results[0]),Axis_t(results[1]),Stat_t(results[2]));
               TAKEACTION_END
            }
            gCurrentTableHist =  ((TH1 *)obj);
            break;
         case -4:
            TAKEACTION_BEGIN
            if (results[2]) {
               if (gVmin[0] > results[1]) gVmin[0] = results[1];
               if (gVmax[0] < results[1]) gVmax[0] = results[1];
               if (gVmin[1] > results[0]) gVmin[1] = results[0];
               if (gVmax[1] < results[0]) gVmax[1] = results[0];
            }
            TAKEACTION_END
            nchans = gNbins[1];
            if (gVmin[1] >= gVmax[1]) { gVmin[1] -= 1; gVmax[1] += 1;}
            FindGoodLimits(nchans,gNbins[1],gVmin[1],gVmax[1]);
            ((TProfile*)obj)->SetBins(gNbins[1],gVmin[1],gVmax[1]);
            // Intentional fall though
         case  4:
            TAKEACTION_BEGIN
            if (results[2]) ((TProfile*)obj)->Fill(Axis_t(results[0]),Axis_t(results[1]),Stat_t(results[2]));
            TAKEACTION_END
            break;
         case -12:
            TAKEACTION_BEGIN
            if (results[2]) {
               if (gVmin[0] > results[1]) gVmin[0] = results[1];
               if (gVmax[0] < results[1]) gVmax[0] = results[1];
               if (gVmin[1] > results[0]) gVmin[1] = results[0];
               if (gVmax[1] < results[0]) gVmax[1] = results[0];
            }
            TAKEACTION_END
            nchans = gNbins[0];
            if (gVmin[0] >= gVmax[0]) { gVmin[0] -= 1; gVmax[0] += 1;}
            FindGoodLimits(nchans,gNbins[0],gVmin[0],gVmax[0]);
            if (gVmin[1] >= gVmax[1]) { gVmin[1] -= 1; gVmax[1] += 1;}
            FindGoodLimits(nchans,gNbins[1],gVmin[1],gVmax[1]);
            ((TH2F*)obj)->SetBins(gNbins[1],gVmin[1],gVmax[1],gNbins[0],gVmin[0],gVmax[0]);
            // Intentional fall though
         case  12: {
            if (!strstr(option,"same") && !strstr(option,"goff")) {
               ((TH2F*)obj)->DrawCopy(option);
               gPad->Update();
            }
//            pm->SetMarkerStyle(GetMarkerStyle());
//            pm->SetMarkerColor(GetMarkerColor());
//            pm->SetMarkerSize(GetMarkerSize());
            Float_t *x = new Float_t[lastEntry-firstentry]; // pm->GetX();
            Float_t *y = new Float_t[lastEntry-firstentry]; // pm->GetY();
            Float_t u, v;
            Float_t umin = gPad->GetUxmin();
            Float_t umax = gPad->GetUxmax();
            Float_t vmin = gPad->GetUymin();
            Float_t vmax = gPad->GetUymax();
            Int_t pointIndex = 0;
            TAKEACTION_BEGIN
            if (results[2]) {
               u = gPad->XtoPad(results[0]);
               v = gPad->YtoPad(results[1]);
               if (u < umin) u = umin;
               if (u > umax) u = umax;
               if (v < vmin) v = vmin;
               if (v > vmax) v = vmax;
               x[pointIndex] = u;
               y[pointIndex] = v;
               pointIndex++;
            }
            TAKEACTION_END
            if (pointIndex && !strstr(option,"goff")) {
               TPolyMarker *pm = new TPolyMarker(pointIndex,x,y);
               pm->Draw();
               pm->SetBit(kCanDelete);
            }
            if (!((TH2F*)obj)->TestBit(kCanDelete))
               if (pointIndex)
                  for(i=0;i<pointIndex;i++) ((TH2F*)obj)->Fill(x[i], y[i]);
            delete [] x; delete [] y;
            gCurrentTableHist = ((TH1*)obj);
            }
            break;
         case -13:
            TAKEACTION_BEGIN
            if (results[3]) {
               if (gVmin[0] > results[2]) gVmin[0] = results[2];
               if (gVmax[0] < results[2]) gVmax[0] = results[2];
               if (gVmin[1] > results[1]) gVmin[1] = results[1];
               if (gVmax[1] < results[1]) gVmax[1] = results[1];
               if (gVmin[2] > results[0]) gVmin[2] = results[0];
               if (gVmax[2] < results[0]) gVmax[2] = results[0];
            }
            TAKEACTION_END
            rmin[0] = gVmin[2]; rmin[1] = gVmin[1]; rmin[2] = gVmin[0];
            rmax[0] = gVmax[2]; rmax[1] = gVmax[1]; rmax[2] = gVmax[0];
            gPad->Clear();
            gPad->Range(-1,-1,1,1);
            TView::CreateView(1,rmin,rmax);
            // Intentional fall though
         case 13: {
            TPolyMarker3D *pm3d = new TPolyMarker3D(lastEntry-firstentry);
            pm3d->SetBit(kCanDelete);
//            pm3d->SetMarkerStyle(GetMarkerStyle());
//            pm3d->SetMarkerColor(GetMarkerColor());
//            pm3d->SetMarkerSize(GetMarkerSize());
            TAKEACTION_BEGIN
            if (results[3]) pm3d->SetNextPoint(results[0],results[1],results[2]);
            TAKEACTION_END
            pm3d->Draw();
         }
         break;
         default:
            Error("EntryLoop","unknown action \"%d\" for table <%s>", action, GetName());
            break;
      };
   }
   gInterpreter->CallFunc_Delete(callfunc);
   gInterpreter->ClassInfo_Delete(globals);
   gInterpreter->UnloadFile((Char_t *)exprFileName);
   delete [] addressArray;
   return kTRUE;
}

//______________________________________________________________________________
TTable::TTable(const char *name, Int_t size) : TDataSet(name),
         fSize(size),fN(0), fTable(0),fMaxIndex(0)
{
   // Default TTable ctor.
   if (size == 0) Warning("TTable(0)","Wrong table format");
}

//______________________________________________________________________________
TTable::TTable(const char *name, Int_t n,Int_t size) : TDataSet(name),
        fSize(size),fN(0),fTable(0),fMaxIndex(0)
{
   // Create TTable object and set array size to n longs.
   if (n > 0) Set(n);
}

//______________________________________________________________________________
TTable::TTable(const char *name, Int_t n, Char_t *table,Int_t size) : TDataSet(name),
         fSize(size),fN(0),fTable(0),fMaxIndex(0)
{
   // Create TTable object and initialize it with values of array.

   Set(n, table);
}

//______________________________________________________________________________
TTable::TTable(const char *name, const char *type, Int_t n, Char_t *array, Int_t size)
         : TDataSet(name),fSize(size),fTable(0),fMaxIndex(0)
{
   // Create TTable object and initialize it with values of array.

   fTable = array;
   SetType(type);
   SetfN(n);
}

//______________________________________________________________________________
TTable::TTable(const TTable &table):TDataSet(table)
{
   // Copy constructor.
   fTable    = 0;
   SetUsedRows(table.GetNRows());
   fSize     = table.GetRowSize();
   SetfN(table.fN);
   Set(table.fN, table.fTable);
}

//______________________________________________________________________________
TTable &TTable::operator=(const TTable &rhs)
{
   // TTable assignment operator.
   // This operator REALLOCATEs this table to fit the number of
   // the USED rows of the source table if any

   if (strcmp(GetType(),rhs.GetType()) == 0) {
      if (this != &rhs && rhs.GetNRows() >0 ){
         Set(rhs.GetNRows(), rhs.fTable);
         SetUsedRows(rhs.GetNRows());
      }
   } else
      Error("operator=","Can not copy <%s> table into <%s> table", rhs.GetType(),GetType());
   return *this;
}

//______________________________________________________________________________
TTable::~TTable()
{
   // Delete TTable object.
   Delete();
}

//______________________________________________________________________________
void TTable::Adopt(Int_t n, void *arr)
{
   // Adopt array arr into TTable, i.e. don't copy arr but use it directly
   // in TTable. User may not delete arr, TTable dtor will do it.

   Clear();

   SetfN(n); SetUsedRows(n);
   fTable = (char *)arr;
}

//______________________________________________________________________________
Int_t TTable::AddAt(const void *row)
{
  // Add        the "row" at the GetNRows() position, and
  // reallocate the table if neccesary,               and
  // return     the row index the "row" has occupied.
  //
  // row == 0 see method TTable::AddAt(const void *row, Int_t i)

   Int_t gap = GetTableSize() - GetNRows();
   // do we need to add an extra space?
   if (gap < 1) ReAllocate(GetTableSize() + TMath::Max(1,Int_t(0.3*GetTableSize())));
   Int_t indx = GetNRows();
   AddAt(row,indx);
   return indx;
}
//______________________________________________________________________________
void TTable::AddAt(const void *row, Int_t i)
{
   // Add    one element ("row") of structure at position "i".
   // Check  for out of bounds.
   //
   //        If the row == 0 the "i" cell is still occupied and
   // filled with the pattern "ff"

   if (!BoundsOk("TTable::AddAt", i))
      i = 0;
   if (row) memcpy(fTable+i*fSize,row,fSize);
   else memset(fTable+i*fSize,127,fSize);
   SetUsedRows(TMath::Max((Int_t)i+1,Int_t(fMaxIndex)));
}

//______________________________________________________________________________
void TTable::CopyStruct(Char_t *dest, const Char_t *src)
{
 // Copy the C-structure src into the new location
 // the length of the strucutre is defined by this class descriptor
   ::memcpy(dest,src,fSize*fN);
}
//______________________________________________________________________________
void TTable::CopySet(TTable &array)
{
   //to be documented
   array.Set(fN);
   CopyStruct(array.fTable,fTable);
}
//______________________________________________________________________________
const Char_t *TTable::GetColumnComment(Int_t columnIndex) const {
   // Get a comment from the table descriptor
   TDataSetIter nextComment(GetRowDescriptors()->MakeCommentField(kFALSE));
   TDataSet *nxc = 0;
   for (int i=0; i<= columnIndex; i++) nxc = nextComment();
   return nxc ? nxc->GetTitle() : 0;
}
//______________________________________________________________________________
Long_t TTable::AppendRows(const void *row, UInt_t nRows)
{
   // Append nRows row of the array "row" to the table
   // return
   //    - the new table size (# of table rows)
   //    - 0 if the object doesn't own the internal array and can not expand it
   if (!TestBit(kIsNotOwn) && row && nRows ) {
      Int_t indx = GetNRows();
      ReAllocate(nRows);
      // Copy (insert) the extra staff in
      ::memmove(fTable+indx*fSize,row,fSize*nRows);
   }
   return TestBit(kIsNotOwn) ? 0 : GetSize();
}
//______________________________________________________________________________
Long_t TTable::InsertRows(const void *row, Long_t indx, UInt_t nRows)
{
  // void InsertRows(cons void *row, Long_t indx, UInt_t nRows)
  //
  // Insert one or several rows into the table at "indx" position
  // The rest table stuff is shifted down
  //
  //  cons void    - a pointer to the array of rows to be inserted
  //  Long_t indx =  The position these rows will be inserted to
  //  Int_t nRows  - the total number of rows to be inserted
  //                 = 1 "by default
  //  return:
  //  The number of the rows has been shifted to accomodate
  //  the new rows.
  //
   Long_t nShifted = 0;
   if (nRows > 0) {
      // Shift the table down
      nShifted = CopyRows(this, indx, indx+nRows, GetNRows()+nRows);
      // Copy (insert) the extra staff in
      ::memmove(fTable+indx*fSize,row,fSize*nRows);
   }
   return nShifted;

}
//______________________________________________________________________________
void *TTable::ReAllocate()
{
  // Reallocate this table leaving only (used rows)+1 allocated
  // GetTableSize() = GetNRows() + 1
  // returns a pointer to the first row of the reallocated table
  // Note:
  // The table is reallocated if it is an owner of the internal array

   ReAlloc(GetNRows()+1);
   return (void *)fTable;
}
//______________________________________________________________________________
void *TTable::ReAllocate(Int_t newsize)
{
  // Reallocate this table leaving only <newsize> allocated
  // GetTableSize() = newsize;
  // returns a pointer to the first row of the reallocated table
  // Note:
  // The table is reallocated if it is an owner of the internal array

   if (newsize > fN) ReAlloc(newsize);
   return (void *)fTable;
}

//______________________________________________________________________________
void TTable::ReAlloc(Int_t newsize)
{
  // The table is reallocated if it is an owner of the internal array
   if (!TestBit(kIsNotOwn) && newsize > 0) {
      void *arr = 0;
      Int_t sleepCounter = 0;
      while (!(arr =  realloc(fTable,fSize*newsize))) {
         sleepCounter++;
         Warning("ReAlloc",
              "Not enough memory to Reallocate %d bytes for table <%s::%s>. Please cancel some jobs",
              newsize, GetType(),GetName());
         gSystem->Sleep(1000*600);
         if (sleepCounter > 30) {
            Error("ReAlloc","I can not wait anymore. Good bye");
            assert(0);
         }
      }
      SetfN(newsize);
      fTable = (char *)arr;
   }
}

//______________________________________________________________________________
Char_t *TTable::Create()
{
   // Allocate a space for the new table, if any
   // Sleep for a while if space is not available and try again
   if (!fTable) {
      void *ptr = 0;
      Int_t sleepCounter = 0;
      while (!(ptr = malloc(fSize*fN))) {
         sleepCounter++;
         Warning("Create",
            "Not enough memory to allocate %d rows for table <%s::%s>. Please cancel some jobs",
            fN, GetType(),GetName());
         gSystem->Sleep(1000*600);
         if (sleepCounter > 30){
            Error("Create","I can not wait anymore. Good bye");
            assert(0);
         }
      }
      fTable = (Char_t *)ptr;
      // make sure all link-columns are zero
      memset(fTable,0,fSize*fN);
   }
   return fTable;
}

//______________________________________________________________________________
void TTable::Browse(TBrowser *b){
   // Wrap each table coulumn with TColumnView object to browse.
   if (!b) return;
   TDataSet::Browse(b);
   Int_t nrows = TMath::Min(Int_t(GetNRows()),6);
   if (nrows == 0) nrows = 1;
   Print(0,nrows);
   // Add the table columns to the browser
   UInt_t nCol = GetNumberOfColumns();
   for (UInt_t i = 0;i<nCol;i++){
      TColumnView *view = 0;
      UInt_t nDim = GetDimensions(i);
      const Char_t *colName = GetColumnName(i);
      if (!nDim) { // scalar
         // This will cause a small memory leak
         // unless TBrowser recognizes kCanDelete bit
         if( GetColumnType(i)== kPtr) {
            UInt_t offset = GetOffset(i);
            TTableMap *m = *(TTableMap **)(((char *)GetArray())+offset);
            if (m) {
               TString nameMap = "*";
               nameMap += m->Table()->GetName();
               b->Add(m,nameMap.Data());
            }
         } else {
            view = new TColumnView(GetColumnName(i),this);
            view->SetBit(kCanDelete);
            b->Add(view,view->GetName());
         }
      } else {     // array
         const UInt_t *indx = GetIndexArray(i);
         UInt_t totalSize = 1;
         UInt_t k;
         for (k=0;k<nDim; k++) totalSize *= indx[k];
         for (k=0;k<totalSize;k++) {
            TString buffer;
            buffer.Form("%s[%d]",colName,k);
            view = new TColumnView(buffer,this);
            view->SetBit(kCanDelete);
            b->Add(view,view->GetName());
         }
      }
   }
}

//______________________________________________________________________________
void TTable::Clear(Option_t *opt)
{
   // Deletes the internal array of this class
   // if this object does own its internal table

   if (!fTable) return;
   Bool_t dtor = kFALSE;
   dtor = opt && (strcmp(opt,gDtorName)==0);
   if (!opt || !opt[0] || dtor ) {
      if (! TestBit(kIsNotOwn)) {
         if (!dtor) ResetMap();
         free(fTable);
      }
      fTable    = 0;
      fMaxIndex = 0;
      SetfN(0);
      return;
   }
}

//______________________________________________________________________________
void TTable::Delete(Option_t *opt)
{
   //
   // Delete the internal array and free the memory it occupied
   // if this object did own this array
   //
   // Then perform TDataSet::Delete(opt)
   Clear(gDtorName);
   TDataSet::Delete(opt);
}

//______________________________________________________________________________
TClass  *TTable::GetRowClass() const
{
   //to be documented
   TClass *cl = 0;
   TTableDescriptor *dsc = GetRowDescriptors();
   if (dsc) cl = dsc->RowClass();
   else Error("GetRowClass()","Table descriptor of <%s::%s> table lost",
             GetName(),GetType());
   return cl;
}

//______________________________________________________________________________
Long_t TTable::GetNRows() const {
// Returns the number of the used rows for the wrapped table
   return fMaxIndex;
}

//______________________________________________________________________________
Long_t TTable::GetRowSize() const {
// Returns the size (in bytes) of one table row
   return fSize;
}

//______________________________________________________________________________
Long_t TTable::GetTableSize() const {
// Returns the number of the allocated rows
   return fN;
}

//______________________________________________________________________________
void TTable::Fit(const char *formula ,const char *varexp, const char *selection,Option_t *option ,Option_t *goption,Int_t nentries, Int_t firstentry)
{
//*-*-*-*-*-*-*-*-*Fit a projected item(s) from a TTable*-*-*-*-*-*-*-*-*-*
//*-*              =======================================
//
//  formula is a TF1 expression.
//
//  See TTable::Draw for explanations of the other parameters.
//
//  By default the temporary histogram created is called htemp.
//  If varexp contains >>hnew , the new histogram created is called hnew
//  and it is kept in the current directory.
//  Example:
//    table.Fit(pol4,"sqrt(x)>>hsqrt","y>0")
//    will fit sqrt(x) and save the histogram as "hsqrt" in the current
//    directory.
//

   TString opt(option);
   opt += "goff";

   Draw(varexp,selection,opt,nentries,firstentry);

   TH1 *hfit = gCurrentTableHist;
   if (hfit) {
      Printf("hname=%s, formula=%s, option=%s, goption=%s\n",hfit->GetName(),formula,option,goption);
      // remove bit temporary
      Bool_t canDeleteBit = hfit->TestBit(kCanDelete);
      if (canDeleteBit)  hfit->ResetBit(kCanDelete);
      hfit->Fit(formula,option,goption);
      if (TestBit(canDeleteBit))   hfit->SetBit(kCanDelete);
   }
   else      Printf("ERROR hfit=0\n");
}

//______________________________________________________________________________
const Char_t *TTable::GetType() const
{
//Returns the type of the wrapped C-structure kept as the TNamed title
   return GetTitle();
}

//______________________________________________________________________________
Bool_t TTable::IsFolder() const {
   // return Folder flag to be used by TBrowse object
   // The table is a folder if
   //  - it has sub-dataset
   //    or
   //  - GetNRows > 0
   return kTRUE; // to provide the "fake" folder bit to workaround TKey::Browse()

#if 0
   // this became useless due TKey::Browse new implementation
   return
   (fList && fList->Last() ? kTRUE : kFALSE)
   ||
     (GetNRows() > 0);
#endif
}

//______________________________________________________________________________
Int_t TTable::NaN()
{
//
// return the total number of the NaN for float/double cells of this table
// Thanks Victor Perevoztchikov
//

   EColumnType code;
   char const *cell,*colname,*table;
   double word;
   int icol,irow,colsize,wordsize,nwords,iword,nerr,offset;

   TTableDescriptor *rowDes = GetRowDescriptors();
   assert(rowDes!=0);
   table = (const char*)GetArray();

   int ncols = rowDes->GetNumberOfColumns();

   int lrow  = GetRowSize();
   int nrows = GetNRows  ();
   nerr =0;
   for (icol=0; icol < ncols; icol++) {// loop over cols
      code = rowDes->GetColumnType(icol);
      if (code!=kFloat && code!=kDouble) continue;

      offset   = rowDes->GetOffset    (icol);
      colsize  = rowDes->GetColumnSize(icol);
      wordsize = rowDes->GetTypeSize  (icol);
      nwords = colsize/wordsize;
      for (irow=0; irow < nrows; irow++) { //loop over rows
         cell = table + offset + irow*lrow;
         for (iword=0;iword<nwords; iword++,cell+=wordsize) { //words in col
            word = (code==kDouble) ? *(double*)cell : *(float*)cell;
            if (TMath::Finite(word))     continue;
//              ERROR FOUND
            nerr++; colname = rowDes->GetColumnName(icol);
            Warning("NaN"," Table %s.%s.%d\n",GetName(),colname,irow);
         }
      }
   }
   return nerr;
}

//______________________________________________________________________________
TTable *TTable::New(const Char_t *name, const Char_t *type, void *array, UInt_t size)
{
  // This static method creates a new TTable object if provided

   TTable *table = 0;
   if (type && name) {
      TString tableType(type);
      TString t = tableType.Strip();

      TString classname("St_");
      classname += t;
      TClass *cl = TClass::GetClass(classname);
      if (cl) {
         table = (TTable *)cl->New();
         if (table) {
            table->SetTablePointer(array);
            table->SetName(name);
            table->SetfN(size);
            table->SetUsedRows(size);
         }
      }
   }
   return table;
}
//______________________________________________________________________________
Bool_t TTable::OutOfBoundsError(const char *where, Int_t i) const
{
   // Generate an out-of-bounds error. Always returns false.
   Error(where, "index %d out of bounds (size: %d, this: 0x%lx)", i, fN, (Long_t)this);
   return kFALSE;
}
//______________________________________________________________________________
Char_t *TTable::Print(Char_t *strbuf,Int_t lenbuf) const
{
   // Create IDL table defintion (to be used for XDF I/O)
   Int_t iOut = 0;

   TTableDescriptor *dscT = GetRowDescriptors();
   if (!dscT ) {
      Error("Print"," No dictionary entry for <%s> structure", GetTitle());
      if (lenbuf>0) iOut += snprintf(strbuf,lenbuf," *** Errror ***");
      return strbuf;
   }

   TROOT::IndentLevel();
   if (lenbuf>0) {
      // cut of the "_st" suffix
      Char_t *typenam =  new Char_t [strlen(dscT->GetName())+1];
      strlcpy(typenam,dscT->GetName(),strlen(dscT->GetName())+1);
      // look for the last "_"
      Char_t *last = strrchr(typenam,'_');
      // Check whether it is "_st"
      Char_t *eon = 0;
      if (last) eon = strstr(last,"_st");
      // Cut it off if any
      if (eon) *eon = '\0';
      iOut += snprintf(strbuf+iOut,lenbuf-iOut,"struct %s {",typenam);
      delete [] typenam;
   } else {
      std::cout << "struct " << dscT->GetName() << " {" << std::endl;
   }

   TTableDescriptor::iterator dsc  = dscT->begin();
   TTableDescriptor::iterator dscE = dscT->end();
   TDataSetIter nextComment(dscT->MakeCommentField(kFALSE));
   for (;dsc != dscE; dsc++) {
      TROOT::IndentLevel();
      TString name = GetTypeName(EColumnType((*dsc).fType));
      if (lenbuf>0) {
         // convert C type names to CORBA type names
         name.ReplaceAll("unsigned char","octet");
         name.ReplaceAll("int","long");
         iOut += snprintf(strbuf+iOut,lenbuf-iOut," %s %s",name.Data(),(*dsc).fColumnName);
      } else
         std::cout << '\t'<< name.Data() << '\t'<< (*dsc).fColumnName;

      Int_t indx;
      Int_t dim = (*dsc).fDimensions;
      for  (indx = 0; indx < dim; indx++) {
         if (lenbuf>0)
            iOut += snprintf(strbuf+iOut,lenbuf-iOut,"[%d]",(*dsc).fIndexArray[indx]);
         else
            std::cout <<  "[" << std::dec << (*dsc).fIndexArray[indx]<<"]";
      }
      // print comment if any
      TDataSet *nxc = nextComment();
      if (lenbuf>0)
         iOut += snprintf(strbuf+iOut,lenbuf-iOut, ";");
      else {
         const char *title = nxc ? nxc->GetTitle() : " ";
         std::cout << ";\t//" << title << std::endl;
      }
   } /* dsc */

   TROOT::IndentLevel();
   if (lenbuf>0)
      iOut += snprintf(strbuf+iOut,lenbuf-iOut, "}");
   else
      std::cout << "}" << std::endl;
   return strbuf;
}

//______________________________________________________________________________
const Char_t *TTable::PrintHeader() const
{
  // Print general table inforamtion
   std::cout << std::endl << " ---------------------------------------------------------------------------------------" << std::endl
        <<  " " << Path()
                <<"  Allocated rows: "<<fN
                <<"\t Used rows: "<<fMaxIndex
                <<"\t Row size: "      << fSize << " bytes"
        <<std::endl;
   return 0;
}

//______________________________________________________________________________
const Char_t *TTable::Print(Int_t row, Int_t rownumber, const Char_t *, const Char_t *) const
{
  //const Char_t *TTable::Print(Int_t row, Int_t rownumber, const Char_t *colfirst, const Char_t *collast) const
  //
  //  Print the contents of internal table per COLUMN.
  //
  //  row       - the index of the first row to print (counting from ZERO)
  //  rownumber - the total number of rows to print out (=10 by default)
  //
  //  (No use !) Char_t *colfirst, *collast - the names of the first/last
  //                                          to print out (not implemented yet)
  //
  //--------------------------------------------------------------
   // Check bounds and adjust it
   Int_t const width = 8;
   Int_t rowStep = 10; // The maximun values to print per line
   Int_t rowNumber = rownumber;
   if (row  > Int_t(GetSize()) || GetSize() == UInt_t(0))  {
      PrintHeader();
      std::cout  << " ======================================================================================" << std::endl
           << "   There are " << GetSize() << " allocated rows for this table only"                     << std::endl
             << " ======================================================================================" << std::endl;
      return 0;
   }
   if (rowNumber > Int_t(GetSize()-row)) rowNumber = GetSize()-row;
   if (!rowNumber) return 0;
   rowStep = TMath::Min(rowStep,rowNumber);

   Int_t cdate = 0;
   Int_t ctime = 0;
   UInt_t *cdatime = 0;
   Bool_t isdate = kFALSE;

   TTableDescriptor *dscT = GetRowDescriptors();
   if (!dscT ) return 0;

   //  3. Loop by "rowStep x lines"

   const Char_t  *startRow = (const Char_t *)GetArray() + row*GetRowSize();
   Int_t rowCount = rowNumber;
   Int_t thisLoopLenth = 0;
   const Char_t  *nextRow = 0;
   while (rowCount) {
      PrintHeader();
      if  (GetNRows() == 0) {// to Print empty table header
         std::cout  << " ======================================================================================" << std::endl
               << "   There is NO filled row in this table"                                                 << std::endl
               << " ======================================================================================" << std::endl;
         return 0;
      }
      std::cout << " Table: " << dscT->GetName()<< "\t";
      for (Int_t j = row+rowNumber-rowCount; j<row+rowNumber-rowCount+rowStep && j < row+rowNumber ;j++) {
         Int_t hW = width-2;
         if (j>=10) hW -= (int)TMath::Log10(float(j))-1;
         std::cout  << std::setw(hW) << "["<<j<<"]";
         std::cout  << " :" ;
      }
      std::cout << std::endl
      <<       " ======================================================================================" << std::endl;
      TTableDescriptor::iterator member = dscT->begin();
      TTableDescriptor::iterator   dscE = dscT->end();
      TDataSetIter nextComment(dscT->MakeCommentField(kFALSE));

      for (; member != dscE; member++){
         TString membertype = GetTypeName(EColumnType((*member).fType));
         isdate = kFALSE;
         if (strcmp((*member).fColumnName,"fDatime") == 0 && EColumnType((*member).fType) == kUInt)
                                                                                   isdate = kTRUE;
         std::cout << membertype.Data();

         // Add the dimensions to "array" members
         Int_t dim = (*member).fDimensions;
         Int_t indx = 0;
         UInt_t *arrayLayout = 0;
         if (dim) {
            arrayLayout = new UInt_t[dim];
            memset(arrayLayout,0,dim*sizeof(Int_t));
         }
         Int_t arrayLength  = 1;
         while (indx < dim ){ // Take in account the room this index will occupy
            arrayLength *= (*member).fIndexArray[indx];
            indx++;
         }
         // Encode data value or pointer value
         Int_t offset = (*member).fOffset;
         Int_t thisStepRows;
         thisLoopLenth = TMath::Min(rowCount,rowStep);
         Int_t indexOffset;
         Bool_t breakLoop = kFALSE;

         for (indexOffset=0; indexOffset < arrayLength && !breakLoop; indexOffset++) {
            nextRow = startRow;

            if (!indexOffset) std::cout << "\t" << (*member).fColumnName;
            else              std::cout << "\t" << std::setw(strlen((*member).fColumnName)) << " ";

            if (dim) {
               for (Int_t i=0;i<dim;i++) std::cout << "["<<std::dec<<arrayLayout[i]<<"]";
               ArrayLayout(arrayLayout,(*member).fIndexArray,dim);
            }
            std::cout << "\t";
            if ( strlen((*member).fColumnName)+3*dim < 8) std::cout << "\t";

            for (thisStepRows = 0;thisStepRows < thisLoopLenth; thisStepRows++,nextRow += GetRowSize()) {
               const char *pointer = nextRow + offset  + indexOffset*(*member).fTypeSize;
               if (isdate) {
                  cdatime = (UInt_t*)pointer;
                  TDatime::GetDateTime(cdatime[0],cdate,ctime);
                  std::cout << cdate << "/" << ctime;
               } else if ((*member).fType == kChar && dim == 1) {
                  char charbuffer[11];
                  strlcpy(charbuffer,pointer,TMath::Min(10,arrayLength)+1);
                  charbuffer[10] = 0;
                  std::cout << "\"" << charbuffer;
                  if (arrayLength > 10)
                     std::cout << " . . . ";
                  std::cout << "\"";
                  breakLoop = kTRUE;
               } else {
                  AsString((void *)pointer,EColumnType((*member).fType),width,std::cout);
                  std::cout << " :";
               }
            }
            // Encode  the column's comment
            if (indexOffset==0) {
               TDataSet *nxc = nextComment();
               std::cout << " " << (const char *)(nxc ? nxc->GetTitle() : "no comment");
            }
            std::cout << std::endl;
         }
         if (arrayLayout) delete [] arrayLayout;
      }
      rowCount -= thisLoopLenth;
      startRow  = nextRow;
   }
   std::cout << "---------------------------------------------------------------------------------------" << std::endl;
   return 0;
}
//______________________________________________________________________________
void TTable::PrintContents(Option_t *) const
{
   //to be documented
   TDataSet::PrintContents();
   TROOT::IndentLevel();
   Printf("\tclass %s: public TTable\t --> Allocated rows: %d\t Used rows: %d\t Row size: %d bytes\n",
         IsA()->GetName(),int(fN),int(fMaxIndex),int(fSize));

}

//______________________________________________________________________________
void TTable::Project(const char *hname, const char *varexp, const char *selection, Option_t *option,Int_t nentries, Int_t firstentry)
{
//*-*-*-*-*-*-*-*-*Make a projection of a TTable using selections*-*-*-*-*-*-*
//*-*              =============================================
//
//   Depending on the value of varexp (described in Draw) a 1-D,2-D,etc
//   projection of the TTable will be filled in histogram hname.
//   Note that the dimension of hname must match with the dimension of varexp.
//

   TString var;
   var.Form("%s>>%s",varexp,hname);

   TString opt(option);
   opt += "goff";

   Draw(var,selection,opt,nentries,firstentry);
}

//______________________________________________________________________________
Int_t TTable::Purge(Option_t *opt)
{
   // Shrink the table to free the unused but still allocated rows
   ReAllocate();
   return TDataSet::Purge(opt);
}

//______________________________________________________________________________
void TTable::SavePrimitive(std::ostream &out, Option_t * /*= ""*/)
{
//   Save a primitive as a C++ statement(s) on output stream "out".
   UInt_t arrayLayout[10],arraySize[10];
   const unsigned char *pointer=0,*startRow=0;
   int i,rowCount;unsigned char ic;

   out << "TDataSet *CreateTable() { " << std::endl;

   Int_t rowNumber =  GetNRows();
   TTableDescriptor *dscT = GetRowDescriptors();

//                      Is anything Wrong??
   if (!rowNumber || !dscT ) {//
      out << "// The output table was bad-defined!" << std::endl
          << " fprintf(stderr, \"Bad table found. Please remove me\\n\");" << std::endl
          << " return 0; } "    << std::endl;
      return;
   }

   startRow = (const UChar_t *)GetArray();
   assert(startRow!=0);

   const Char_t *rowId = "row";
   const Char_t *tableId = "tableSet";

//                      Generate the header

   const char *className = IsA()->GetName();

   out << "// -----------------------------------------------------------------" << std::endl;
   out << "// "   << Path()
       << " Allocated rows: "<< rowNumber
       <<"  Used rows: "<<      rowNumber
       <<"  Row size: " << fSize << " bytes"                 << std::endl;
   out << "// "  << " Table: " << dscT->GetName()<<"[0]--> "
       << dscT->GetName()<<"["<<rowNumber-1 <<"]"            << std::endl;
   out << "// ====================================================================" << std::endl;
   out << "// ------  Test whether this table share library was loaded ------"      << std::endl;
   out << "  if (!TClass::GetClass(\"" << className << "\")) return 0;"    << std::endl;
   out <<    dscT->GetName() << " " << rowId << ";" << std::endl
       <<  className << " *" << tableId << " = new "
       <<  className
       << "(\""<<GetName()<<"\"," << GetNRows() << ");" << std::endl
       << "//" <<std::endl ;

//              Row loop
   TDataSetIter nextComment(dscT->MakeCommentField(kFALSE));
   for (rowCount=0;rowCount<rowNumber; rowCount++,startRow += fSize, nextComment.Reset()) {     //row loop
      out << "memset(" << "&" << rowId << ",0," << tableId << "->GetRowSize()" << ");" << std::endl ;

//              Member loop
   TTableDescriptor::iterator member  = dscT->begin();
   TTableDescriptor::iterator   dscE  = dscT->end();
   for (; member != dscE; member++) {  //LOOP over members
      TString memberType = GetTypeName(EColumnType((*member).fType));
      TString memberName((*member).fColumnName);

       // Encode  the column's comment
      TDataSet *nxc = nextComment();
      TString memberTitle(nxc ? nxc->GetTitle() : "no comment");

      Int_t offset = (*member).fOffset;
      int mayBeName = 0;
      if (memberName.Index("name",0,TString::kIgnoreCase)>=0) mayBeName=1999;
      if (memberName.Index("file",0,TString::kIgnoreCase)>=0) mayBeName=1999;
      int typeSize = (*member).fTypeSize;

//              Add the dimensions to "array" members
      Int_t dim = (*member).fDimensions;
      if (dim) memset(arrayLayout,0,dim*sizeof(Int_t));
      Int_t arrayLength  = 1;
      for (int indx=0;indx < dim ;indx++){
         arraySize[indx] =  (*member).fIndexArray[indx];;
         arrayLength *= arraySize[indx];
      }

//                      Special case, character array
      int charLen = (memberType.CompareTo("char")==0);
      if (charLen) {    //Char case
         charLen=arrayLength;
         pointer = startRow + offset;
//                      Actual size of char array
         if (mayBeName) {
            charLen = strlen((const char*)pointer)+1;
            if (charLen>arrayLength) charLen = arrayLength;
         } else {
            for(;charLen && !pointer[charLen-1];charLen--){;}
            if (!charLen) charLen=1;
         }

         out << " memcpy(&" << rowId << "." << (const char*)memberName;
         out << ",\"";
         for (int ii=0; ii<charLen;ii++) {
            ic = pointer[ii];
            if (ic && (isalnum(ic)
             || strchr("!#$%&()*+-,./:;<>=?@{}[]_|~",ic))) {//printable
               out << ic;
            } else {                                      //nonprintable
               out << "\\x" << std::setw(2) << std::setfill('0') << std::hex << (unsigned)ic ;
               out << std::setw(1) << std::setfill(' ') << std::dec;
            }
         }
         out << "\"," << std::dec << charLen << ");";
         out << "// " << (const char*)memberTitle << std::endl;
         continue;
      } //EndIf of char case

//                      Normal member
      Int_t indexOffset;
      for (indexOffset=0; indexOffset < arrayLength ; indexOffset++) {//array loop
         out << std::setw(3) << " " ;
         out << " " << rowId << "." << (const char*)memberName;

         if (dim) {
            for (i=0;i<dim;i++) {out << "["<<std::dec<<arrayLayout[i]<<"]";}
            ArrayLayout(arrayLayout,arraySize,dim);}

//                      Generate "="
            out << "\t = ";

            pointer = startRow + offset  + indexOffset*typeSize;

            AsString((void *)pointer,EColumnType((*member).fType),10,out);

//                      Encode data member title
            if (indexOffset==0)  out << "; // " << (const char*)memberTitle;
            out << ";" << std::endl;
         }//end array loop
      }//end of member loop

      out << tableId << "->AddAt(&" << rowId <<");" << std::endl;

   }//end of row loop
   out << "// ----------------- end of code ---------------" << std::endl
       << " return (TDataSet *)tableSet;" << std::endl
       << "}"  << std::endl;
   return;
}

//______________________________________________________________________________
void TTable::Set(Int_t n)
{
   // Set array size of TTable object to n longs. If n<0 leave array unchanged.
   if (n < 0) return;
   if (fN != n)  Clear();
   SetfN(n);
   if (fN == 0) return;
   Create();
   if (TTable::GetNRows()) Reset();
}
//______________________________________________________________________________
void TTable::SetTablePointer(void *table)
{
   //to be documented
   if (fTable) free(fTable);
   fTable = (Char_t *)table;
}

//______________________________________________________________________________
void TTable::SetType(const char *const type)
{
   //to be documented
   SetTitle(type);
}

//______________________________________________________________________________
static Char_t *GetExpressionFileName()
{
   // Create a name of the file in the temporary directory if any
   const Char_t *tempDirs =  gSystem->Getenv("TEMP");
   if (!tempDirs)  tempDirs =  gSystem->Getenv("TMP");
   if (!tempDirs) tempDirs = "/tmp";
   if (gSystem->AccessPathName(tempDirs)) tempDirs = ".";
   if (gSystem->AccessPathName(tempDirs)) return 0;
   TString fileName;
   fileName.Form("Selection.C.%d.tmp",gSystem->GetPid());
   return  gSystem->ConcatFileName(tempDirs,fileName.Data());
}

//______________________________________________________________________________
Char_t *TTable::MakeExpression(const Char_t *expressions[],Int_t nExpressions)
{
  // Create CINT macro to evaluate the user-provided expresssion
  // Expression may contains:
  //   -  the table columen names
  //   - 2 meta names: i$ - the current column index,
  //                   n$ - the total table size provided by TTable::GetNRows() method
  //
  // return the name of temporary file with the current expressions
  //
   const Char_t *typeNames[] = {"NAN","float", "int",  "long",  "short",         "double"
                                ,"unsigned int","unsigned long", "unsigned short","unsigned char"
                                ,"char", "TTableMap &"};
   const char *resID     = "results";
   const char *addressID = "address";
   Char_t *fileName = GetExpressionFileName();
   if (!fileName) {
      Error("MakeExpression","Can not create a temporary file");
      return 0;
   }

   std::ofstream str;
   str.open(fileName);
   if (str.bad() ) {
      Error("MakeExpression","Can not open the temporary file <%s>",fileName);
      delete [] fileName;
      return 0;
   }

   TTableDescriptor *dsc = GetRowDescriptors();
   const tableDescriptor_st *descTable  = dsc->GetTable();
   // Create function
   str << "void SelectionQWERTY(float *"<<resID<<", float **"<<addressID<< ", int& i$, int& n$ )"   << std::endl;
   str << "{"                                                        << std::endl;
   int i = 0;
   for (i=0; i < dsc->GetNRows(); i++,descTable++ ) {
      // Take the column name
      const Char_t *columnName = descTable->fColumnName;
      const Char_t *type = 0;
      // First check whether we do need this column
      for (Int_t exCount = 0; exCount < nExpressions; exCount++) {
         if (expressions[exCount] && expressions[exCount][0] && strstr(expressions[exCount],columnName)) goto LETSTRY;
      }
      continue;
LETSTRY:
      Bool_t isScalar = !(descTable->fDimensions);
      Bool_t isFloat = descTable->fType == kFloat;
      type = typeNames[descTable->fType];
      str << type << " ";
      if (!isScalar)  str << "*";

      str << columnName << " = " ;
      if (isScalar)   str << "*(";
      if (!isFloat)   str << "(" << type << "*)";
      str << addressID << "[" << i << "]";
      if (isScalar)   str << ")" ;
      str << ";" << std::endl;
   }
   // Create expressions
   for (i=0; i < nExpressions; i++ ) {
      if (expressions[i] && expressions[i][0])
         str << " "<<resID<<"["<<i<<"]=(float)(" << expressions[i] << ");"  << std::endl;
//      if (i == nExpressions-1 && i !=0 )
//          str  << "  if ("<<resID<<"["<<i<<"] == 0){ return; }" << std::endl;
   };
   str << "}" << std::endl;
   str.close();
   // Create byte code and check syntax
   if (str.good()) return fileName;
   delete [] fileName;
   return 0;
}

//______________________________________________________________________________
void TTable::Reset(Int_t c)
{
   // Fill the entire table with byte "c" ;
   ///     c=0 "be default"
   if (fTable) {
      ResetMap(kTRUE);
      ::memset(fTable,c,fSize*fN);
      if (c) ResetMap(kFALSE);
   }
}

//______________________________________________________________________________
void TTable::ResetMap(Bool_t wipe)
{
   // Clean all filled columns with the pointers to TTableMap
   // if any
   //  wipe = kTRUE - delete all object the Map's point to
   //         kFALSE - zero pointer, do not call "delete" though
   piterator links     = pbegin();
   piterator lastLinks = pend();
   for (;links != lastLinks;links++) {
      TTableMap **mp = (TTableMap **)(*links);
      if (wipe) delete *mp;
      *mp = 0;
   }
}
//______________________________________________________________________________
void TTable::Set(Int_t n, Char_t *array)
{
   // Set array size of TTable object to n longs and copy array.
   // If n<0 leave array unchanged.

   if (n < 0) return;
   if (fN < n) Clear();

   SetfN(n);

   if (fN == 0) return;
   Create();
   CopyStruct(fTable,array);
   fMaxIndex = n;
}

//_______________________________________________________________________
void TTable::StreamerTable(TBuffer &b,Version_t version)
{
   // Stream an object of class TTable.
   if (b.IsReading()) {
      TDataSet::Streamer(b);
      b >> fN;
      StreamerHeader(b,version);
      //   Create a table to fit nok rows
      Set(fMaxIndex);
   } else {
      TDataSet::Streamer(b);
      b << fN;
      StreamerHeader(b,version);
   }
}

//_______________________________________________________________________
void TTable::StreamerHeader(TBuffer &b, Version_t version)
{
   // Read "table parameters first"
   if (b.IsReading()) {
      Long_t rbytes;
      if (version) { }   // version to remove compiler warning
#ifdef __STAR__
      if (version < 3) {
         // skip obsolete  STAR fields (for the sake of the backward compatibility)
         //   char name[20];   /* table name */
         //   char type[20];   /* table type */
         //   long maxlen;     /* # rows allocated */
         long len = b.Length() + (20+4) + (20+4) + 4;
         b.SetBufferOffset(len);
      }
#endif
      b >> fMaxIndex;         // fTableHeader->nok;          /* # rows filled */
      b >> rbytes;            /* number of bytes per row */
      if (GetRowSize() == -1) fSize = rbytes;
      if (rbytes - GetRowSize()) {
         Warning("StreamerHeader","Schema evolution warning: row size mismatch: expected %ld, read %ld bytes\n",GetRowSize(),rbytes);
      }

#ifdef __STAR__
      if (version < 3) {
         // skip obsolete  STAR fields (for the sake of the backward compatibility)
         //    long dsl_pointer;  /* swizzled (DS_DATASET_T*) */
         //    long data_pointer; /* swizzled (char*) */
         long len = b.Length() + (4) + (4);
         b.SetBufferOffset(len);
      }
#endif
   } else {
      b << fMaxIndex;         //fTableHeader->nok;          /* # rows filled */
      b << fSize;             //  fTableHeader->rbytes;     /* number of bytes per row */
   }
}
//_______________________________________________________________________
Int_t TTable::SetfN(Long_t len)
{
   //to be documented
   fN = len;
   return fN;
}
//____________________________________________________________________________
#ifdef StreamElelement
#define __StreamElelement__ StreamElelement
#undef StreamElelement
#endif

#define StreamElementIn(type)  case TTableDescriptor::_NAME2_(k,type):        \
if (evolutionOn) {                                  \
    if (nextCol->fDimensions)  {                    \
      if (nextCol->fOffset != UInt_t(-1)) {         \
         R__b.ReadFastArray((_NAME2_(type,_t) *)(row+nextCol->fOffset),nextCol->fSize/sizeof(_NAME2_(type,_t)));   \
      } else {                                        \
          _NAME2_(type,_t) *readPtrV = new _NAME2_(type,_t)[nextCol->fSize/sizeof(_NAME2_(type,_t))];              \
          R__b.ReadFastArray((_NAME2_(type,_t) *)(row+nextCol->fOffset),nextCol->fSize/sizeof(_NAME2_(type,_t)));  \
          delete [] readPtrV;                       \
          readPtrV = 0;                             \
      }                                             \
    }                                               \
    else  {                                         \
      _NAME2_(type,_t) skipBuffer;                  \
      _NAME2_(type,_t) *readPtr =  (_NAME2_(type,_t) *)(row+nextCol->fOffset); \
      if (nextCol->fOffset == UInt_t(-1)) readPtr = &skipBuffer;               \
      R__b >> *readPtr;                             \
    }                                               \
} else {                                            \
  if (nextCol->fDimensions)  {                      \
    R__b.ReadFastArray  ((_NAME2_(type,_t) *)(row+nextCol->fOffset),nextCol->fSize/sizeof(_NAME2_(type,_t)));  \
  } else                                                       \
    R__b >> *(_NAME2_(type,_t) *)(row+nextCol->fOffset);       \
}                                                              \
break

#define StreamElementOut(type) case TTableDescriptor::_NAME2_(k,type):    \
if (nextCol->fDimensions)                                    \
   R__b.WriteFastArray((_NAME2_(type,_t) *)(row+nextCol->fOffset), nextCol->fSize/sizeof(_NAME2_(type,_t))); \
else                                                         \
   R__b << *(_NAME2_(type,_t) *)(row+nextCol->fOffset);      \
break

//______________________________________________________________________________
TTableDescriptor  *TTable::GetRowDescriptors() const
{
   //to be documented
   TTableDescriptor *dsc = 0;
   if (IsA()) dsc = GetDescriptorPointer();
   if (!dsc) {
      Error("GetRowDescriptors()","%s has no dictionary !",GetName());
      dsc = GetTableDescriptors();
      ((TTableDescriptor *)this)->SetDescriptorPointer(dsc);
   }
   return dsc;
}
//______________________________________________________________________________
TTableDescriptor *TTable::GetDescriptorPointer() const
{
   //to be documented
   assert(0);
   return 0;
}

//______________________________________________________________________________
void TTable::SetDescriptorPointer(TTableDescriptor *)
{
   //to be documented
   assert(0);
}

//______________________________________________________________________________
void TTable::Streamer(TBuffer &R__b)
{
   // Stream an array of the "plain" C-structures
   TTableDescriptor *ioDescriptor = GetRowDescriptors();
   TTableDescriptor *currentDescriptor = ioDescriptor;
   Version_t R__v = 0;
   if (R__b.IsReading()) {
      // Check whether the file is the "obsolete" one
      R__v = R__b.ReadVersion();
      Bool_t evolutionOn = kFALSE;
      if (R__v>=2) {
         if (IsA() != TTableDescriptor::Class()) {
            if (R__v>3) {
               R__b >> ioDescriptor;
            } else {  // backward compatibility
               ioDescriptor =  new TTableDescriptor();
               ioDescriptor->Streamer(R__b);
            }
            if (!currentDescriptor) {
               currentDescriptor = ioDescriptor;
               SetDescriptorPointer(currentDescriptor);
            }
            if (currentDescriptor->fSecondDescriptor != ioDescriptor) {
               // Protection against of memory leak.
               delete currentDescriptor->fSecondDescriptor;
               currentDescriptor->fSecondDescriptor = ioDescriptor;
            }

            // compare two descriptors
            evolutionOn = (Bool_t)ioDescriptor->UpdateOffsets(currentDescriptor);
         }
      }
      TTable::StreamerTable(R__b,R__v);
      if (fMaxIndex <= 0) return;
      char *row= fTable;
      Int_t maxColumns = ioDescriptor->NumberOfColumns();
      Int_t rowSize = GetRowSize();
      if (evolutionOn) Reset(0); // Clean table
      for (Int_t indx=0;indx<fMaxIndex;indx++,row += rowSize) {
         tableDescriptor_st *nextCol = ioDescriptor->GetTable();
         for (Int_t colCounter=0; colCounter < maxColumns; colCounter++,nextCol++) {
            // Stream one table row supplied
            switch(nextCol->fType) {
               StreamElementIn(Float);
               StreamElementIn(Int);
               StreamElementIn(Long);
               StreamElementIn(Short);
               StreamElementIn(Double);
               StreamElementIn(UInt);
               StreamElementIn(ULong);
               StreamElementIn(UChar);
               StreamElementIn(Char);
               StreamElementIn(Bool);
               case TTableDescriptor::kPtr: {
                  Ptr_t readPtr;
                  R__b >> readPtr;
                  if (evolutionOn) {
                     // TTableMap skipBuffer;
                     //  R__b >> readPtr;
                     if (nextCol->fOffset == UInt_t(-1)) delete readPtr; // skip this member
                     else *(Ptr_t *)(row+nextCol->fOffset) = readPtr;
                  } else {
                     *(Ptr_t *)(row+nextCol->fOffset) = readPtr;
               }
               break;
                                       }
               default:
               break;
            };
         }
      }
   } else {
      TSeqCollection *save = fList;
      R__b.WriteVersion(TTable::IsA());

      //      if (Class_Version()==2)
      if (IsA() != TTableDescriptor::Class()) {
         if ( Class_Version()>3 ) {
            R__b << ioDescriptor;
         } else {  // backward compatibility
            ioDescriptor->Streamer(R__b);
         }
      } else {
         if ( Class_Version()<=3 ) fList = 0;
      }

      TTable::StreamerTable(R__b);
      if (fMaxIndex <= 0) return;
      char *row= fTable;
      Int_t maxColumns = ioDescriptor->NumberOfColumns();
      Int_t rowSize = GetRowSize();
      for (Int_t indx=0;indx<fMaxIndex;indx++,row += rowSize) {
         tableDescriptor_st *nextCol = ioDescriptor->GetTable();
         for (Int_t colCounter=0; colCounter < maxColumns; colCounter++,nextCol++) {
            // Stream one table row supplied
            switch(nextCol->fType) {
               StreamElementOut(Float);
               StreamElementOut(Int);
               StreamElementOut(Long);
               StreamElementOut(Short);
               StreamElementOut(Double);
               StreamElementOut(UInt);
               StreamElementOut(ULong);
               StreamElementOut(UChar);
               StreamElementOut(Char);
               StreamElementOut(Bool);
               case TTableDescriptor::kPtr:
                  R__b << *(Ptr_t *)(row+nextCol->fOffset);
                  break;
               default:
                  break;
            };
         }
      }
      fList = save;
   }
}
#ifdef __StreamElelement__
#define StreamElelement __StreamElelement__
#undef __StreamElelement__
#endif

//_______________________________________________________________________
void TTable::Update()
{
   //to be documented
}

//_______________________________________________________________________
void TTable::Update(TDataSet *set, UInt_t opt)
{
 // Kill the table current data
 // and adopt those from set
   if (set->HasData()) {
      // Check whether the new table has the same type
      if (strcmp(GetTitle(),set->GetTitle()) == 0 ) {
         TTable *table =  (TTable *)set;
         Adopt(table->GetSize(),table->GetArray());
         // Adopt can not distniguish the "allocated" and "used"
         // rows,
         // correct the corrupted number of the "used" rows
         SetUsedRows(table->GetNRows());
         // mark that object lost the STAF table and can not delete it anymore
         table->SetBit(kIsNotOwn);
         // mark we took over of this STAF table
         ResetBit(kIsNotOwn);
      } else
         Error("Update",
             "This table is <%s> but the updating one has a wrong type <%s>",GetTitle(),set->GetTitle());
   }
   TDataSet::Update(set,opt);
}
//_______________________________________________________________________
const char *TTable::TableDictionary(const char *className,const char *structName,TTableDescriptor *&ColDescriptors)
{
   // Query the TClass instance for the C-stucture dicitonary
   // This method is to be used  with TableImp CPP macro (see $ROOTSYS/table/inc/Ttypes.h
   if (className){/*NotUsed*/};
   TClass *r = TClass::GetClass(structName,1);
   ColDescriptors = new TTableDescriptor(r);
   return structName;
}


 //  ----   Table descriptor service   ------
Int_t        TTable::GetColumnIndex(const Char_t *columnName) const {return GetRowDescriptors()->ColumnByName(columnName);}
const Char_t *TTable::GetColumnName(Int_t columnIndex) const {return GetRowDescriptors()->ColumnName(columnIndex); }
const UInt_t *TTable::GetIndexArray(Int_t columnIndex) const {return GetRowDescriptors()->IndexArray(columnIndex); }
UInt_t       TTable::GetNumberOfColumns()              const {return GetRowDescriptors()->NumberOfColumns();       }

UInt_t       TTable::GetOffset(Int_t columnIndex)      const {return GetRowDescriptors()->Offset(columnIndex); }
Int_t        TTable::GetOffset(const Char_t *columnName) const {return GetRowDescriptors()->Offset(columnName); }

UInt_t       TTable::GetColumnSize(Int_t columnIndex)  const {return GetRowDescriptors()->ColumnSize(columnIndex); }
Int_t        TTable::GetColumnSize(const Char_t *columnName) const {return GetRowDescriptors()->ColumnSize(columnName); }

UInt_t       TTable::GetTypeSize(Int_t columnIndex)    const {return GetRowDescriptors()->TypeSize(columnIndex); }
Int_t        TTable::GetTypeSize(const Char_t *columnName) const {return GetRowDescriptors()->TypeSize(columnName); }

UInt_t       TTable::GetDimensions(Int_t columnIndex)  const {return GetRowDescriptors()->Dimensions(columnIndex); }
Int_t        TTable::GetDimensions(const Char_t *columnName) const {return GetRowDescriptors()->Dimensions(columnName); }

TTable::EColumnType  TTable::GetColumnType(Int_t columnIndex)  const {return GetRowDescriptors()->ColumnType(columnIndex); }
TTable::EColumnType  TTable::GetColumnType(const Char_t *columnName) const {return GetRowDescriptors()->ColumnType(columnName); }

//  pointer iterator
//________________________________________________________________________________________________________________
TTable::piterator::piterator(const TTable *t,EColumnType type): fCurrentRowIndex(0),fCurrentColIndex(0),fRowSize(0),fCurrentRowPtr(0),fCurrentColPtr(0)
{
   //to be documented
   Int_t sz = 0;
   if (t) sz = t->GetNRows();
   if (sz) {
      fRowSize       = t->GetRowSize();
      fCurrentRowPtr = (const Char_t *)t->GetArray();

      TTableDescriptor    *tabsDsc       = t->GetRowDescriptors();
      TTableDescriptor::iterator ptr     = tabsDsc->begin();
      TTableDescriptor::iterator lastPtr = tabsDsc->end();
      UInt_t i =0;
      for( i = 0; ptr != lastPtr; ptr++,i++)
         if ( tabsDsc->ColumnType(i) == type ) fPtrs.push_back(tabsDsc->Offset(i));
      if (fPtrs.size()==0) {
         MakeEnd(t->GetNRows());
      } else {
         column();
      }
   } else {
      MakeEnd(0);
   }
} // piterator(TTable *)

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