HROOT-0.6.4: csrc/HROOT.cpp

#include <iostream>

#include "HROOT.h"

#include "TMath.h"
#include "TFile.h"
#include "TStyle.h"
#include "TLatex.h"
#include "TTree.h"
#include "TChain.h"
#include "THStack.h"

#include "TNamed.h"
#include "TDictionary.h"
#include "TClass.h"

#include "TAtt3D.h"
#include "TAttAxis.h"
#include "TAttBBox.h"
#include "TAttCanvas.h"
#include "TAttFill.h"
#include "TAttImage.h"
#include "TAttLine.h"
#include "TAttMarker.h"
#include "TAttPad.h"
#include "TAttParticle.h"
#include "TAttText.h"

#include "TGraph.h"
#include "TGraphAsymmErrors.h"
#include "TCutG.h"
#include "TGraphBentErrors.h"
#include "TGraphErrors.h"
#include "TGraphPolar.h"
#include "TGraphQQ.h"

#include "TEllipse.h"
#include "TArc.h"
#include "TCrown.h"
#include "TLine.h"
#include "TArrow.h"
#include "TGaxis.h"
#include "TShape.h"
#include "TBRIK.h"
#include "TTUBE.h"
#include "TPCON.h"
// #include "TPolyLineShape.h"
#include "TSPHE.h"
#include "TXTRU.h"
#include "TBox.h"
#include "TPave.h"
#include "TPaveText.h"
#include "TDiamond.h"
#include "TPaveStats.h"
#include "TPavesText.h"
#include "TLegend.h"
#include "TPaletteAxis.h"
#include "TPaveLabel.h"
#include "TPaveClass.h"
#include "TWbox.h"
#include "TFrame.h"
#include "TSliderBox.h"
#include "TChain.h"
#include "TProofChain.h"
#include "THbookTree.h"
#include "TNtuple.h"
#include "TNtupleD.h"
#include "TTreeSQL.h"

#include "TPolyLine.h"
#include "TCurlyLine.h"
#include "TCurlyArc.h"
#include "TEfficiency.h"


#include "TLorentzVector.h"
#include "TStyle.h" 
#include "TF1.h"
#include "TAxis.h"

#include "TLine.h"
#include "TWbox.h"

#include "TArray.h"
#include "TArrayC.h"
#include "TArrayD.h"
#include "TArrayF.h"
#include "TArrayI.h"
#include "TArrayL.h"
#include "TArrayL64.h"

#include "TH1.h"
#include "TH2.h"
#include "TH3.h"

#include "TH1C.h"
#include "TH1D.h"
#include "TH1F.h"
#include "TH1I.h"
#include "TH1S.h"

#include "TH2C.h"
#include "TH2D.h"
#include "TH2F.h"
#include "TH2I.h"
#include "TH2Poly.h"
//#include "TH2S"

#include "TH3C.h"
#include "TH3D.h"
#include "TH3F.h"
#include "TH3I.h"
#include "TH3S.h"

#include "TQObject.h"
#include "TVirtualPad.h"
#include "TPad.h"
#include "TButton.h"
#include "TGroupButton.h"
#include "TCanvas.h"
#include "TDialogCanvas.h"
#include "TInspectCanvas.h"
#include "TEvePad.h"
#include "TSlider.h"



#include "TTreePlayer.h"
#include "TApplication.h"
#include "TRint.h"

#include "TRandom.h"
#include "TProfile.h"
#include "TCollection.h"
#include "TSeqCollection.h"
#include "TObjArray.h"


using namespace std;


template<class ToType, class FromType>
const ToType* to_const(const FromType* x) {
  return reinterpret_cast<const ToType*>(x);
}

template<class ToType, class FromType>
ToType* to_nonconst(FromType* x) {
  return reinterpret_cast<ToType*>(x);
}



#undef ROOT_DELETABLE_DEFINITIONVIRT
#define ROOT_DELETABLE_DEFINITIONVIRT(Type)\
void Type ## _delete ( Type ## _p p )\
{\
delete (to_nonconst<Type,Type ## _t>(p)) ; \
}

#undef ROOT_TOBJECT_DEFINITIONVIRT
#define ROOT_TOBJECT_DEFINITIONVIRT(Type)\
const char * Type ## _GetName ( Type ## _p p )\
{\
return to_nonconst<Type,Type ## _t>(p)->GetName();\
}\
void Type ## _Draw ( Type ## _p p, const char * option )\
{\
to_nonconst<Type,Type ## _t>(p)->Draw(option);\
}\
TObject_p Type ## _FindObject ( Type ## _p p, const char * name )\
{\
return to_nonconst<TObject_t,TObject>((TObject*)to_nonconst<Type,Type ## _t>(p)->FindObject(name));\
}\
void Type ## _SaveAs ( Type ## _p p, const char * filename, const char * option )\
{\
to_nonconst<Type,Type ## _t>(p)->SaveAs(filename, option);\
}\
int  Type ## _Write ( Type ## _p p, const char * name, int  option, int  bufsize )\
{\
return to_nonconst<Type,Type ## _t>(p)->Write(name, option, bufsize);\
}\
TClass_p Type ## _IsA ( Type ## _p p )\
{\
return to_nonconst<TClass_t,TClass>((TClass*)to_nonconst<Type,Type ## _t>(p)->IsA());\
}

#undef ROOT_TNAMED_DEFINITIONVIRT
#define ROOT_TNAMED_DEFINITIONVIRT(Type)\
void Type ## _SetTitle ( Type ## _p p, const char * name )\
{\
to_nonconst<Type,Type ## _t>(p)->SetTitle(name);\
}

#undef ROOT_TDICTIONARY_DEFINITIONVIRT
#define ROOT_TDICTIONARY_DEFINITIONVIRT(Type)\


#undef ROOT_TCLASS_DEFINITIONVIRT
#define ROOT_TCLASS_DEFINITIONVIRT(Type)\


#undef ROOT_TFORMULA_DEFINITIONVIRT
#define ROOT_TFORMULA_DEFINITIONVIRT(Type)\
double Type ## _GetParameter ( Type ## _p p, int  idx )\
{\
return to_nonconst<Type,Type ## _t>(p)->GetParameter(idx);\
}\
void Type ## _SetParameter ( Type ## _p p, int  idx, double value )\
{\
to_nonconst<Type,Type ## _t>(p)->SetParameter(idx, value);\
}

#undef ROOT_TATT3D_DEFINITIONVIRT
#define ROOT_TATT3D_DEFINITIONVIRT(Type)\


#undef ROOT_TATTAXIS_DEFINITIONVIRT
#define ROOT_TATTAXIS_DEFINITIONVIRT(Type)\
void Type ## _SetLabelColor ( Type ## _p p, int  color )\
{\
to_nonconst<Type,Type ## _t>(p)->SetLabelColor(color);\
}\
void Type ## _SetLabelSize ( Type ## _p p, double size )\
{\
to_nonconst<Type,Type ## _t>(p)->SetLabelSize(size);\
}\
void Type ## _SetTickLength ( Type ## _p p, double length )\
{\
to_nonconst<Type,Type ## _t>(p)->SetTickLength(length);\
}\
void Type ## _SetTitleOffset ( Type ## _p p, double offset )\
{\
to_nonconst<Type,Type ## _t>(p)->SetTitleOffset(offset);\
}\
void Type ## _SetNdivisions ( Type ## _p p, int  n, int optim )\
{\
to_nonconst<Type,Type ## _t>(p)->SetNdivisions(n, optim);\
}

#undef ROOT_TATTBBOX_DEFINITIONVIRT
#define ROOT_TATTBBOX_DEFINITIONVIRT(Type)\


#undef ROOT_TATTCANVAS_DEFINITIONVIRT
#define ROOT_TATTCANVAS_DEFINITIONVIRT(Type)\


#undef ROOT_TATTFILL_DEFINITIONVIRT
#define ROOT_TATTFILL_DEFINITIONVIRT(Type)\
void Type ## _SetFillColor ( Type ## _p p, int  color )\
{\
to_nonconst<Type,Type ## _t>(p)->SetFillColor(color);\
}\
void Type ## _SetFillStyle ( Type ## _p p, int  style )\
{\
to_nonconst<Type,Type ## _t>(p)->SetFillStyle(style);\
}

#undef ROOT_TATTIMAGE_DEFINITIONVIRT
#define ROOT_TATTIMAGE_DEFINITIONVIRT(Type)\


#undef ROOT_TATTLINE_DEFINITIONVIRT
#define ROOT_TATTLINE_DEFINITIONVIRT(Type)\
void Type ## _SetLineColor ( Type ## _p p, int  color )\
{\
to_nonconst<Type,Type ## _t>(p)->SetLineColor(color);\
}

#undef ROOT_TATTMARKER_DEFINITIONVIRT
#define ROOT_TATTMARKER_DEFINITIONVIRT(Type)\


#undef ROOT_TATTPAD_DEFINITIONVIRT
#define ROOT_TATTPAD_DEFINITIONVIRT(Type)\


#undef ROOT_TATTPARTICLE_DEFINITIONVIRT
#define ROOT_TATTPARTICLE_DEFINITIONVIRT(Type)\


#undef ROOT_TATTTEXT_DEFINITIONVIRT
#define ROOT_TATTTEXT_DEFINITIONVIRT(Type)\
void Type ## _SetTextColor ( Type ## _p p, int  tcolor )\
{\
to_nonconst<Type,Type ## _t>(p)->SetTextColor(tcolor);\
}\
void Type ## _SetTextAlign ( Type ## _p p, int  align )\
{\
to_nonconst<Type,Type ## _t>(p)->SetTextAlign(align);\
}\
void Type ## _SetTextSize ( Type ## _p p, double tsize )\
{\
to_nonconst<Type,Type ## _t>(p)->SetTextSize(tsize);\
}

#undef ROOT_THSTACK_DEFINITIONVIRT
#define ROOT_THSTACK_DEFINITIONVIRT(Type)\


#undef ROOT_TF1_DEFINITIONVIRT
#define ROOT_TF1_DEFINITIONVIRT(Type)\


#undef ROOT_TGRAPH_DEFINITIONVIRT
#define ROOT_TGRAPH_DEFINITIONVIRT(Type)\


#undef ROOT_TGRAPHASYMMERRORS_DEFINITIONVIRT
#define ROOT_TGRAPHASYMMERRORS_DEFINITIONVIRT(Type)\


#undef ROOT_TCUTG_DEFINITIONVIRT
#define ROOT_TCUTG_DEFINITIONVIRT(Type)\


#undef ROOT_TGRAPHBENTERRORS_DEFINITIONVIRT
#define ROOT_TGRAPHBENTERRORS_DEFINITIONVIRT(Type)\


#undef ROOT_TGRAPHERRORS_DEFINITIONVIRT
#define ROOT_TGRAPHERRORS_DEFINITIONVIRT(Type)\


#undef ROOT_TGRAPHPOLAR_DEFINITIONVIRT
#define ROOT_TGRAPHPOLAR_DEFINITIONVIRT(Type)\


#undef ROOT_TGRAPHQQ_DEFINITIONVIRT
#define ROOT_TGRAPHQQ_DEFINITIONVIRT(Type)\


#undef ROOT_TELLIPSE_DEFINITIONVIRT
#define ROOT_TELLIPSE_DEFINITIONVIRT(Type)\


#undef ROOT_TARC_DEFINITIONVIRT
#define ROOT_TARC_DEFINITIONVIRT(Type)\


#undef ROOT_TCROWN_DEFINITIONVIRT
#define ROOT_TCROWN_DEFINITIONVIRT(Type)\


#undef ROOT_TLINE_DEFINITIONVIRT
#define ROOT_TLINE_DEFINITIONVIRT(Type)\


#undef ROOT_TARROW_DEFINITIONVIRT
#define ROOT_TARROW_DEFINITIONVIRT(Type)\


#undef ROOT_TGAXIS_DEFINITIONVIRT
#define ROOT_TGAXIS_DEFINITIONVIRT(Type)\


#undef ROOT_TSHAPE_DEFINITIONVIRT
#define ROOT_TSHAPE_DEFINITIONVIRT(Type)\


#undef ROOT_TBRIK_DEFINITIONVIRT
#define ROOT_TBRIK_DEFINITIONVIRT(Type)\


#undef ROOT_TTUBE_DEFINITIONVIRT
#define ROOT_TTUBE_DEFINITIONVIRT(Type)\


#undef ROOT_TPCON_DEFINITIONVIRT
#define ROOT_TPCON_DEFINITIONVIRT(Type)\


#undef ROOT_TSPHE_DEFINITIONVIRT
#define ROOT_TSPHE_DEFINITIONVIRT(Type)\


#undef ROOT_TXTRU_DEFINITIONVIRT
#define ROOT_TXTRU_DEFINITIONVIRT(Type)\


#undef ROOT_TBOX_DEFINITIONVIRT
#define ROOT_TBOX_DEFINITIONVIRT(Type)\


#undef ROOT_TPAVE_DEFINITIONVIRT
#define ROOT_TPAVE_DEFINITIONVIRT(Type)\


#undef ROOT_TPAVETEXT_DEFINITIONVIRT
#define ROOT_TPAVETEXT_DEFINITIONVIRT(Type)\


#undef ROOT_TDIAMOND_DEFINITIONVIRT
#define ROOT_TDIAMOND_DEFINITIONVIRT(Type)\


#undef ROOT_TPAVESTATS_DEFINITIONVIRT
#define ROOT_TPAVESTATS_DEFINITIONVIRT(Type)\


#undef ROOT_TPAVESTEXT_DEFINITIONVIRT
#define ROOT_TPAVESTEXT_DEFINITIONVIRT(Type)\


#undef ROOT_TLEGEND_DEFINITIONVIRT
#define ROOT_TLEGEND_DEFINITIONVIRT(Type)\


#undef ROOT_TPAVELABEL_DEFINITIONVIRT
#define ROOT_TPAVELABEL_DEFINITIONVIRT(Type)\


#undef ROOT_TPAVECLASS_DEFINITIONVIRT
#define ROOT_TPAVECLASS_DEFINITIONVIRT(Type)\


#undef ROOT_TWBOX_DEFINITIONVIRT
#define ROOT_TWBOX_DEFINITIONVIRT(Type)\
void Type ## _SetBorderMode ( Type ## _p p, int  bordermode )\
{\
to_nonconst<Type,Type ## _t>(p)->SetBorderMode(bordermode);\
}

#undef ROOT_TFRAME_DEFINITIONVIRT
#define ROOT_TFRAME_DEFINITIONVIRT(Type)\


#undef ROOT_TSLIDERBOX_DEFINITIONVIRT
#define ROOT_TSLIDERBOX_DEFINITIONVIRT(Type)\


#undef ROOT_TTREE_DEFINITIONVIRT
#define ROOT_TTREE_DEFINITIONVIRT(Type)\


#undef ROOT_TCHAIN_DEFINITIONVIRT
#define ROOT_TCHAIN_DEFINITIONVIRT(Type)\


#undef ROOT_TNTUPLE_DEFINITIONVIRT
#define ROOT_TNTUPLE_DEFINITIONVIRT(Type)\


#undef ROOT_TNTUPLED_DEFINITIONVIRT
#define ROOT_TNTUPLED_DEFINITIONVIRT(Type)\


#undef ROOT_TTREESQL_DEFINITIONVIRT
#define ROOT_TTREESQL_DEFINITIONVIRT(Type)\


#undef ROOT_TPOLYLINE_DEFINITIONVIRT
#define ROOT_TPOLYLINE_DEFINITIONVIRT(Type)\


#undef ROOT_TCURLYLINE_DEFINITIONVIRT
#define ROOT_TCURLYLINE_DEFINITIONVIRT(Type)\


#undef ROOT_TCURLYARC_DEFINITIONVIRT
#define ROOT_TCURLYARC_DEFINITIONVIRT(Type)\


#undef ROOT_TEFFICIENCY_DEFINITIONVIRT
#define ROOT_TEFFICIENCY_DEFINITIONVIRT(Type)\


#undef ROOT_TAXIS_DEFINITIONVIRT
#define ROOT_TAXIS_DEFINITIONVIRT(Type)\


#undef ROOT_TLATEX_DEFINITIONVIRT
#define ROOT_TLATEX_DEFINITIONVIRT(Type)\


#undef ROOT_TTEXT_DEFINITIONVIRT
#define ROOT_TTEXT_DEFINITIONVIRT(Type)\


#undef ROOT_TDIRECTORY_DEFINITIONVIRT
#define ROOT_TDIRECTORY_DEFINITIONVIRT(Type)\
void Type ## _Close ( Type ## _p p, const char * option )\
{\
to_nonconst<Type,Type ## _t>(p)->Close(option);\
}\
TObject_p Type ## _Get ( Type ## _p p, const char * namecycle )\
{\
return to_nonconst<TObject_t,TObject>((TObject*)to_nonconst<Type,Type ## _t>(p)->Get(namecycle));\
}

#undef ROOT_TDIRECTORYFILE_DEFINITIONVIRT
#define ROOT_TDIRECTORYFILE_DEFINITIONVIRT(Type)\


#undef ROOT_TFILE_DEFINITIONVIRT
#define ROOT_TFILE_DEFINITIONVIRT(Type)\


#undef ROOT_TBRANCH_DEFINITIONVIRT
#define ROOT_TBRANCH_DEFINITIONVIRT(Type)\


#undef ROOT_TVIRTUALTREEPLAYER_DEFINITIONVIRT
#define ROOT_TVIRTUALTREEPLAYER_DEFINITIONVIRT(Type)\


#undef ROOT_TTREEPLAYER_DEFINITIONVIRT
#define ROOT_TTREEPLAYER_DEFINITIONVIRT(Type)\


#undef ROOT_TARRAY_DEFINITIONVIRT
#define ROOT_TARRAY_DEFINITIONVIRT(Type)\


#undef ROOT_TARRAYC_DEFINITIONVIRT
#define ROOT_TARRAYC_DEFINITIONVIRT(Type)\


#undef ROOT_TARRAYD_DEFINITIONVIRT
#define ROOT_TARRAYD_DEFINITIONVIRT(Type)\


#undef ROOT_TARRAYF_DEFINITIONVIRT
#define ROOT_TARRAYF_DEFINITIONVIRT(Type)\


#undef ROOT_TARRAYI_DEFINITIONVIRT
#define ROOT_TARRAYI_DEFINITIONVIRT(Type)\


#undef ROOT_TARRAYL_DEFINITIONVIRT
#define ROOT_TARRAYL_DEFINITIONVIRT(Type)\


#undef ROOT_TARRAYL64_DEFINITIONVIRT
#define ROOT_TARRAYL64_DEFINITIONVIRT(Type)\


#undef ROOT_TARRAYS_DEFINITIONVIRT
#define ROOT_TARRAYS_DEFINITIONVIRT(Type)\


#undef ROOT_TH1_DEFINITIONVIRT
#define ROOT_TH1_DEFINITIONVIRT(Type)\
void Type ## _Add ( Type ## _p p, TH1_p h1, double c1 )\
{\
to_nonconst<Type,Type ## _t>(p)->Add(to_nonconst<TH1,TH1_t>(h1), c1);\
}\
void Type ## _AddBinContent ( Type ## _p p, int  bin, double w )\
{\
to_nonconst<Type,Type ## _t>(p)->AddBinContent(bin, w);\
}\
double Type ## _Chi2Test ( Type ## _p p, TH1_p h2, const char * option, double * res )\
{\
return to_nonconst<Type,Type ## _t>(p)->Chi2Test(to_nonconst<TH1,TH1_t>(h2), option, res);\
}\
double Type ## _ComputeIntegral ( Type ## _p p )\
{\
return to_nonconst<Type,Type ## _t>(p)->ComputeIntegral();\
}\
void Type ## _DirectoryAutoAdd ( Type ## _p p, TDirectory_p dir )\
{\
to_nonconst<Type,Type ## _t>(p)->DirectoryAutoAdd(to_nonconst<TDirectory,TDirectory_t>(dir));\
}\
int  Type ## _DistancetoPrimitive ( Type ## _p p, int  px, int  py )\
{\
return to_nonconst<Type,Type ## _t>(p)->DistancetoPrimitive(px, py);\
}\
void Type ## _Divide ( Type ## _p p, TH1_p h1, TH2_p h2, double c1, double c2, const char * option )\
{\
to_nonconst<Type,Type ## _t>(p)->Divide(to_nonconst<TH1,TH1_t>(h1), to_nonconst<TH2,TH2_t>(h2), c1, c2, option);\
}\
Type ## _p Type ## _DrawCopy ( Type ## _p p, const char * option )\
{\
return to_nonconst<Type ## _t, Type>((Type *)to_nonconst<Type,Type ## _t>(p)->DrawCopy(option)) ;\
}\
TH1_p Type ## _DrawNormalized ( Type ## _p p, const char * option, double norm )\
{\
return to_nonconst<TH1_t,TH1>((TH1*)to_nonconst<Type,Type ## _t>(p)->DrawNormalized(option, norm));\
}\
void Type ## _DrawPanel ( Type ## _p p )\
{\
to_nonconst<Type,Type ## _t>(p)->DrawPanel();\
}\
int  Type ## _BufferEmpty ( Type ## _p p, int  action )\
{\
return to_nonconst<Type,Type ## _t>(p)->BufferEmpty(action);\
}\
void Type ## _Eval ( Type ## _p p, TF1_p f1, const char * option )\
{\
to_nonconst<Type,Type ## _t>(p)->Eval(to_nonconst<TF1,TF1_t>(f1), option);\
}\
void Type ## _ExecuteEvent ( Type ## _p p, int  event, int  px, int  py )\
{\
to_nonconst<Type,Type ## _t>(p)->ExecuteEvent(event, px, py);\
}\
TH1_p Type ## _FFT ( Type ## _p p, TH1_p h_output, const char * option )\
{\
return to_nonconst<TH1_t,TH1>((TH1*)to_nonconst<Type,Type ## _t>(p)->FFT(to_nonconst<TH1,TH1_t>(h_output), option));\
}\
int  Type ## _fill1 ( Type ## _p p, double x )\
{\
return to_nonconst<Type,Type ## _t>(p)->Fill(x);\
}\
void Type ## _FillN ( Type ## _p p, int  ntimes, double * x, double * w, int  stride )\
{\
to_nonconst<Type,Type ## _t>(p)->FillN(ntimes, x, w, stride);\
}\
void Type ## _FillRandom ( Type ## _p p, TH1_p h, int  ntimes )\
{\
to_nonconst<Type,Type ## _t>(p)->FillRandom(to_nonconst<TH1,TH1_t>(h), ntimes);\
}\
int  Type ## _FindBin ( Type ## _p p, double x, double y, double z )\
{\
return to_nonconst<Type,Type ## _t>(p)->FindBin(x, y, z);\
}\
int  Type ## _FindFixBin ( Type ## _p p, double x, double y, double z )\
{\
return to_nonconst<Type,Type ## _t>(p)->FindFixBin(x, y, z);\
}\
int  Type ## _FindFirstBinAbove ( Type ## _p p, double threshold, int  axis )\
{\
return to_nonconst<Type,Type ## _t>(p)->FindFirstBinAbove(threshold, axis);\
}\
int  Type ## _FindLastBinAbove ( Type ## _p p, double threshold, int  axis )\
{\
return to_nonconst<Type,Type ## _t>(p)->FindLastBinAbove(threshold, axis);\
}\
void Type ## _FitPanel ( Type ## _p p )\
{\
to_nonconst<Type,Type ## _t>(p)->FitPanel();\
}\
int  Type ## _GetNdivisions ( Type ## _p p, const char * axis )\
{\
return to_nonconst<Type,Type ## _t>(p)->GetNdivisions(axis);\
}\
int  Type ## _GetAxisColor ( Type ## _p p, const char * axis )\
{\
return to_nonconst<Type,Type ## _t>(p)->GetAxisColor(axis);\
}\
int  Type ## _GetLabelColor ( Type ## _p p, const char * axis )\
{\
return to_nonconst<Type,Type ## _t>(p)->GetLabelColor(axis);\
}\
int  Type ## _GetLabelFont ( Type ## _p p, const char * axis )\
{\
return to_nonconst<Type,Type ## _t>(p)->GetLabelFont(axis);\
}\
double Type ## _GetLabelOffset ( Type ## _p p, const char * axis )\
{\
return to_nonconst<Type,Type ## _t>(p)->GetLabelOffset(axis);\
}\
double Type ## _GetLabelSize ( Type ## _p p, const char * axis )\
{\
return to_nonconst<Type,Type ## _t>(p)->GetLabelSize(axis);\
}\
int  Type ## _GetTitleFont ( Type ## _p p, const char * axis )\
{\
return to_nonconst<Type,Type ## _t>(p)->GetTitleFont(axis);\
}\
double Type ## _GetTitleOffset ( Type ## _p p, const char * axis )\
{\
return to_nonconst<Type,Type ## _t>(p)->GetTitleOffset(axis);\
}\
double Type ## _GetTitleSize ( Type ## _p p, const char * axis )\
{\
return to_nonconst<Type,Type ## _t>(p)->GetTitleSize(axis);\
}\
double Type ## _GetTickLength ( Type ## _p p, const char * axis )\
{\
return to_nonconst<Type,Type ## _t>(p)->GetTickLength(axis);\
}\
double Type ## _GetBarOffset ( Type ## _p p )\
{\
return to_nonconst<Type,Type ## _t>(p)->GetBarOffset();\
}\
double Type ## _GetBarWidth ( Type ## _p p )\
{\
return to_nonconst<Type,Type ## _t>(p)->GetBarWidth();\
}\
int  Type ## _GetContour ( Type ## _p p, double * levels )\
{\
return to_nonconst<Type,Type ## _t>(p)->GetContour(levels);\
}\
double Type ## _GetContourLevel ( Type ## _p p, int  level )\
{\
return to_nonconst<Type,Type ## _t>(p)->GetContourLevel(level);\
}\
double Type ## _GetContourLevelPad ( Type ## _p p, int  level )\
{\
return to_nonconst<Type,Type ## _t>(p)->GetContourLevelPad(level);\
}\
int  Type ## _GetBin ( Type ## _p p, int  binx, int  biny, int  binz )\
{\
return to_nonconst<Type,Type ## _t>(p)->GetBin(binx, biny, binz);\
}\
double Type ## _GetBinCenter ( Type ## _p p, int  bin )\
{\
return to_nonconst<Type,Type ## _t>(p)->GetBinCenter(bin);\
}\
double Type ## _GetBinContent1 ( Type ## _p p, int  binx )\
{\
return to_nonconst<Type,Type ## _t>(p)->GetBinContent(binx);\
}\
double Type ## _GetBinContent2 ( Type ## _p p, int  binx, int  biny )\
{\
return to_nonconst<Type,Type ## _t>(p)->GetBinContent(binx, biny);\
}\
double Type ## _GetBinContent3 ( Type ## _p p, int  binx, int  biny, int  binz )\
{\
return to_nonconst<Type,Type ## _t>(p)->GetBinContent(binx, biny, binz);\
}\
double Type ## _GetBinError1 ( Type ## _p p, int  binx )\
{\
return to_nonconst<Type,Type ## _t>(p)->GetBinError(binx);\
}\
double Type ## _GetBinError2 ( Type ## _p p, int  binx, int  biny )\
{\
return to_nonconst<Type,Type ## _t>(p)->GetBinError(binx, biny);\
}\
double Type ## _GetBinError3 ( Type ## _p p, int  binx, int  biny, int  binz )\
{\
return to_nonconst<Type,Type ## _t>(p)->GetBinError(binx, biny, binz);\
}\
double Type ## _GetBinLowEdge ( Type ## _p p, int  bin )\
{\
return to_nonconst<Type,Type ## _t>(p)->GetBinLowEdge(bin);\
}\
double Type ## _GetBinWidth ( Type ## _p p, int  bin )\
{\
return to_nonconst<Type,Type ## _t>(p)->GetBinWidth(bin);\
}\
double Type ## _GetCellContent ( Type ## _p p, int  binx, int  biny )\
{\
return to_nonconst<Type,Type ## _t>(p)->GetCellContent(binx, biny);\
}\
double Type ## _GetCellError ( Type ## _p p, int  binx, int  biny )\
{\
return to_nonconst<Type,Type ## _t>(p)->GetCellError(binx, biny);\
}

#undef ROOT_TH2_DEFINITIONVIRT
#define ROOT_TH2_DEFINITIONVIRT(Type)\
int  Type ## _fill2 ( Type ## _p p, double x, double y )\
{\
return to_nonconst<Type,Type ## _t>(p)->Fill(x, y);\
}\
void Type ## _fillRandom2 ( Type ## _p p, TH1_p h, int  ntimes )\
{\
to_nonconst<Type,Type ## _t>(p)->FillRandom(to_nonconst<TH1,TH1_t>(h), ntimes);\
}\
int  Type ## _findFirstBinAbove2 ( Type ## _p p, double threshold, int  axis )\
{\
return to_nonconst<Type,Type ## _t>(p)->FindFirstBinAbove(threshold, axis);\
}\
int  Type ## _findLastBinAbove2 ( Type ## _p p, double threshold, int  axis )\
{\
return to_nonconst<Type,Type ## _t>(p)->FindLastBinAbove(threshold, axis);\
}\
void Type ## _FitSlicesX ( Type ## _p p, TF1_p f1, int  firstybin, int  lastybin, int  cut, const char * option, TObjArray_p arr )\
{\
to_nonconst<Type,Type ## _t>(p)->FitSlicesX(to_nonconst<TF1,TF1_t>(f1), firstybin, lastybin, cut, option, to_nonconst<TObjArray,TObjArray_t>(arr));\
}\
void Type ## _FitSlicesY ( Type ## _p p, TF1_p f1, int  firstxbin, int  lastxbin, int  cut, const char * option, TObjArray_p arr )\
{\
to_nonconst<Type,Type ## _t>(p)->FitSlicesY(to_nonconst<TF1,TF1_t>(f1), firstxbin, lastxbin, cut, option, to_nonconst<TObjArray,TObjArray_t>(arr));\
}\
double Type ## _GetCorrelationFactor ( Type ## _p p, int  axis1, int  axis2 )\
{\
return to_nonconst<Type,Type ## _t>(p)->GetCorrelationFactor(axis1, axis2);\
}\
double Type ## _GetCovariance ( Type ## _p p, int  axis1, int  axis2 )\
{\
return to_nonconst<Type,Type ## _t>(p)->GetCovariance(axis1, axis2);\
}\
void Type ## _GetStats ( Type ## _p p, double * stats )\
{\
to_nonconst<Type,Type ## _t>(p)->GetStats(stats);\
}\
double Type ## _Integral ( Type ## _p p, int  binx1, int  binx2, int  biny1, int  biny2, const char * option )\
{\
return to_nonconst<Type,Type ## _t>(p)->Integral(binx1, binx2, biny1, biny2, option);\
}\
double Type ## _Interpolate ( Type ## _p p, double x, double y, double z )\
{\
return to_nonconst<Type,Type ## _t>(p)->Interpolate(x, y, z);\
}\
double Type ## _KolmogorovTest ( Type ## _p p, TH1_p h2, const char * option )\
{\
return to_nonconst<Type,Type ## _t>(p)->KolmogorovTest(to_nonconst<TH1,TH1_t>(h2), option);\
}\
TH2_p Type ## _RebinX ( Type ## _p p, int  ngroup, const char * newname )\
{\
return to_nonconst<TH2_t,TH2>((TH2*)to_nonconst<Type,Type ## _t>(p)->RebinX(ngroup, newname));\
}\
TH2_p Type ## _RebinY ( Type ## _p p, int  ngroup, const char * newname )\
{\
return to_nonconst<TH2_t,TH2>((TH2*)to_nonconst<Type,Type ## _t>(p)->RebinY(ngroup, newname));\
}\
TH2_p Type ## _Rebin2D ( Type ## _p p, int  nxgroup, int  nygroup, const char * newname )\
{\
return to_nonconst<TH2_t,TH2>((TH2*)to_nonconst<Type,Type ## _t>(p)->Rebin2D(nxgroup, nygroup, newname));\
}\
void Type ## _PutStats ( Type ## _p p, double * stats )\
{\
to_nonconst<Type,Type ## _t>(p)->PutStats(stats);\
}\
void Type ## _Reset ( Type ## _p p, const char * option )\
{\
to_nonconst<Type,Type ## _t>(p)->Reset(option);\
}\
void Type ## _SetShowProjectionX ( Type ## _p p, int  nbins )\
{\
to_nonconst<Type,Type ## _t>(p)->SetShowProjectionX(nbins);\
}\
void Type ## _SetShowProjectionY ( Type ## _p p, int  nbins )\
{\
to_nonconst<Type,Type ## _t>(p)->SetShowProjectionY(nbins);\
}\
TH1_p Type ## _ShowBackground ( Type ## _p p, int  niter, const char * option )\
{\
return to_nonconst<TH1_t,TH1>((TH1*)to_nonconst<Type,Type ## _t>(p)->ShowBackground(niter, option));\
}\
int  Type ## _ShowPeaks ( Type ## _p p, double sigma, const char * option, double threshold )\
{\
return to_nonconst<Type,Type ## _t>(p)->ShowPeaks(sigma, option, threshold);\
}\
void Type ## _Smooth ( Type ## _p p, int  ntimes, const char * option )\
{\
to_nonconst<Type,Type ## _t>(p)->Smooth(ntimes, option);\
}

#undef ROOT_TH3_DEFINITIONVIRT
#define ROOT_TH3_DEFINITIONVIRT(Type)\


#undef ROOT_TH1C_DEFINITIONVIRT
#define ROOT_TH1C_DEFINITIONVIRT(Type)\


#undef ROOT_TH1D_DEFINITIONVIRT
#define ROOT_TH1D_DEFINITIONVIRT(Type)\


#undef ROOT_TH1F_DEFINITIONVIRT
#define ROOT_TH1F_DEFINITIONVIRT(Type)\


#undef ROOT_TH1I_DEFINITIONVIRT
#define ROOT_TH1I_DEFINITIONVIRT(Type)\


#undef ROOT_TH1S_DEFINITIONVIRT
#define ROOT_TH1S_DEFINITIONVIRT(Type)\


#undef ROOT_TH2C_DEFINITIONVIRT
#define ROOT_TH2C_DEFINITIONVIRT(Type)\


#undef ROOT_TH2D_DEFINITIONVIRT
#define ROOT_TH2D_DEFINITIONVIRT(Type)\


#undef ROOT_TH2F_DEFINITIONVIRT
#define ROOT_TH2F_DEFINITIONVIRT(Type)\


#undef ROOT_TH2I_DEFINITIONVIRT
#define ROOT_TH2I_DEFINITIONVIRT(Type)\


#undef ROOT_TH2POLY_DEFINITIONVIRT
#define ROOT_TH2POLY_DEFINITIONVIRT(Type)\


#undef ROOT_TH2S_DEFINITIONVIRT
#define ROOT_TH2S_DEFINITIONVIRT(Type)\


#undef ROOT_TH3C_DEFINITIONVIRT
#define ROOT_TH3C_DEFINITIONVIRT(Type)\


#undef ROOT_TH3D_DEFINITIONVIRT
#define ROOT_TH3D_DEFINITIONVIRT(Type)\


#undef ROOT_TH3F_DEFINITIONVIRT
#define ROOT_TH3F_DEFINITIONVIRT(Type)\


#undef ROOT_TH3I_DEFINITIONVIRT
#define ROOT_TH3I_DEFINITIONVIRT(Type)\


#undef ROOT_TH3S_DEFINITIONVIRT
#define ROOT_TH3S_DEFINITIONVIRT(Type)\


#undef ROOT_TQOBJECT_DEFINITIONVIRT
#define ROOT_TQOBJECT_DEFINITIONVIRT(Type)\


#undef ROOT_TVIRTUALPAD_DEFINITIONVIRT
#define ROOT_TVIRTUALPAD_DEFINITIONVIRT(Type)\
TFrame_p Type ## _GetFrame ( Type ## _p p )\
{\
return to_nonconst<TFrame_t,TFrame>((TFrame*)to_nonconst<Type,Type ## _t>(p)->GetFrame());\
}\
void Type ## _Range ( Type ## _p p, double x1, double y1, double x2, double y2 )\
{\
to_nonconst<Type,Type ## _t>(p)->Range(x1, y1, x2, y2);\
}

#undef ROOT_TPAD_DEFINITIONVIRT
#define ROOT_TPAD_DEFINITIONVIRT(Type)\


#undef ROOT_TBUTTON_DEFINITIONVIRT
#define ROOT_TBUTTON_DEFINITIONVIRT(Type)\


#undef ROOT_TGROUPBUTTON_DEFINITIONVIRT
#define ROOT_TGROUPBUTTON_DEFINITIONVIRT(Type)\


#undef ROOT_TCANVAS_DEFINITIONVIRT
#define ROOT_TCANVAS_DEFINITIONVIRT(Type)\


#undef ROOT_TDIALOGCANVAS_DEFINITIONVIRT
#define ROOT_TDIALOGCANVAS_DEFINITIONVIRT(Type)\


#undef ROOT_TINSPECTCANVAS_DEFINITIONVIRT
#define ROOT_TINSPECTCANVAS_DEFINITIONVIRT(Type)\


#undef ROOT_TEVEPAD_DEFINITIONVIRT
#define ROOT_TEVEPAD_DEFINITIONVIRT(Type)\


#undef ROOT_TSLIDER_DEFINITIONVIRT
#define ROOT_TSLIDER_DEFINITIONVIRT(Type)\


#undef ROOT_TAPPLICATION_DEFINITIONVIRT
#define ROOT_TAPPLICATION_DEFINITIONVIRT(Type)\
void Type ## _Run ( Type ## _p p, int retrn )\
{\
to_nonconst<Type,Type ## _t>(p)->Run(retrn);\
}

#undef ROOT_TRINT_DEFINITIONVIRT
#define ROOT_TRINT_DEFINITIONVIRT(Type)\


#undef ROOT_TRANDOM_DEFINITIONVIRT
#define ROOT_TRANDOM_DEFINITIONVIRT(Type)\
double Type ## _Gaus ( Type ## _p p, double mean, double sigma )\
{\
return to_nonconst<Type,Type ## _t>(p)->Gaus(mean, sigma);\
}\
double Type ## _Uniform ( Type ## _p p, double x1, double x2 )\
{\
return to_nonconst<Type,Type ## _t>(p)->Uniform(x1, x2);\
}

#undef ROOT_TCOLLECTION_DEFINITIONVIRT
#define ROOT_TCOLLECTION_DEFINITIONVIRT(Type)\


#undef ROOT_TSEQCOLLECTION_DEFINITIONVIRT
#define ROOT_TSEQCOLLECTION_DEFINITIONVIRT(Type)\


#undef ROOT_TOBJARRAY_DEFINITIONVIRT
#define ROOT_TOBJARRAY_DEFINITIONVIRT(Type)\


#undef ROOT_DELETABLE_DEFINITIONNONVIRT
#define ROOT_DELETABLE_DEFINITIONNONVIRT(Type)\


#undef ROOT_TOBJECT_DEFINITIONNONVIRT
#define ROOT_TOBJECT_DEFINITIONNONVIRT(Type)\
Type ## _p Type ## _newTObject (  )\
{\
Type * newp = new Type (); \
return to_nonconst<Type ## _t, Type >(newp);\
}

#undef ROOT_TNAMED_DEFINITIONNONVIRT
#define ROOT_TNAMED_DEFINITIONNONVIRT(Type)\
Type ## _p Type ## _newTNamed ( const char * name, const char * title )\
{\
Type * newp = new Type (name, title); \
return to_nonconst<Type ## _t, Type >(newp);\
}

#undef ROOT_TDICTIONARY_DEFINITIONNONVIRT
#define ROOT_TDICTIONARY_DEFINITIONNONVIRT(Type)\


#undef ROOT_TCLASS_DEFINITIONNONVIRT
#define ROOT_TCLASS_DEFINITIONNONVIRT(Type)\


#undef ROOT_TFORMULA_DEFINITIONNONVIRT
#define ROOT_TFORMULA_DEFINITIONNONVIRT(Type)\
Type ## _p Type ## _newTFormula ( const char * name, const char * formula )\
{\
Type * newp = new Type (name, formula); \
return to_nonconst<Type ## _t, Type >(newp);\
}

#undef ROOT_TATT3D_DEFINITIONNONVIRT
#define ROOT_TATT3D_DEFINITIONNONVIRT(Type)\


#undef ROOT_TATTAXIS_DEFINITIONNONVIRT
#define ROOT_TATTAXIS_DEFINITIONNONVIRT(Type)\
Type ## _p Type ## _newTAttAxis (  )\
{\
Type * newp = new Type (); \
return to_nonconst<Type ## _t, Type >(newp);\
}

#undef ROOT_TATTBBOX_DEFINITIONNONVIRT
#define ROOT_TATTBBOX_DEFINITIONNONVIRT(Type)\


#undef ROOT_TATTCANVAS_DEFINITIONNONVIRT
#define ROOT_TATTCANVAS_DEFINITIONNONVIRT(Type)\
Type ## _p Type ## _newTAttCanvas (  )\
{\
Type * newp = new Type (); \
return to_nonconst<Type ## _t, Type >(newp);\
}

#undef ROOT_TATTFILL_DEFINITIONNONVIRT
#define ROOT_TATTFILL_DEFINITIONNONVIRT(Type)\
Type ## _p Type ## _newTAttFill ( int  fcolor, int  fstyle )\
{\
Type * newp = new Type (fcolor, fstyle); \
return to_nonconst<Type ## _t, Type >(newp);\
}

#undef ROOT_TATTIMAGE_DEFINITIONNONVIRT
#define ROOT_TATTIMAGE_DEFINITIONNONVIRT(Type)\


#undef ROOT_TATTLINE_DEFINITIONNONVIRT
#define ROOT_TATTLINE_DEFINITIONNONVIRT(Type)\
Type ## _p Type ## _newTAttLine ( int  lcolor, int  lstyle, int  lwidth )\
{\
Type * newp = new Type (lcolor, lstyle, lwidth); \
return to_nonconst<Type ## _t, Type >(newp);\
}

#undef ROOT_TATTMARKER_DEFINITIONNONVIRT
#define ROOT_TATTMARKER_DEFINITIONNONVIRT(Type)\
Type ## _p Type ## _newTAttMarker ( int  color, int  style, int  msize )\
{\
Type * newp = new Type (color, style, msize); \
return to_nonconst<Type ## _t, Type >(newp);\
}

#undef ROOT_TATTPAD_DEFINITIONNONVIRT
#define ROOT_TATTPAD_DEFINITIONNONVIRT(Type)\
Type ## _p Type ## _newTAttPad (  )\
{\
Type * newp = new Type (); \
return to_nonconst<Type ## _t, Type >(newp);\
}

#undef ROOT_TATTPARTICLE_DEFINITIONNONVIRT
#define ROOT_TATTPARTICLE_DEFINITIONNONVIRT(Type)\


#undef ROOT_TATTTEXT_DEFINITIONNONVIRT
#define ROOT_TATTTEXT_DEFINITIONNONVIRT(Type)\
Type ## _p Type ## _newTAttText ( int  align, double angle, int  color, int  font, double tsize )\
{\
Type * newp = new Type (align, angle, color, font, tsize); \
return to_nonconst<Type ## _t, Type >(newp);\
}

#undef ROOT_THSTACK_DEFINITIONNONVIRT
#define ROOT_THSTACK_DEFINITIONNONVIRT(Type)\
Type ## _p Type ## _newTHStack ( const char * name, const char * title )\
{\
Type * newp = new Type (name, title); \
return to_nonconst<Type ## _t, Type >(newp);\
}

#undef ROOT_TF1_DEFINITIONNONVIRT
#define ROOT_TF1_DEFINITIONNONVIRT(Type)\
Type ## _p Type ## _newTF1 ( const char * name, const char * formula, double xmin, double xmax )\
{\
Type * newp = new Type (name, formula, xmin, xmax); \
return to_nonconst<Type ## _t, Type >(newp);\
}

#undef ROOT_TGRAPH_DEFINITIONNONVIRT
#define ROOT_TGRAPH_DEFINITIONNONVIRT(Type)\
Type ## _p Type ## _newTGraph ( int  n, double * x, double * y )\
{\
Type * newp = new Type (n, x, y); \
return to_nonconst<Type ## _t, Type >(newp);\
}

#undef ROOT_TGRAPHASYMMERRORS_DEFINITIONNONVIRT
#define ROOT_TGRAPHASYMMERRORS_DEFINITIONNONVIRT(Type)\
Type ## _p Type ## _newTGraphAsymmErrors ( int  n, double * x, double * y, double * exl, double * exh, double * eyl, double * eyh )\
{\
Type * newp = new Type (n, x, y, exl, exh, eyl, eyh); \
return to_nonconst<Type ## _t, Type >(newp);\
}

#undef ROOT_TCUTG_DEFINITIONNONVIRT
#define ROOT_TCUTG_DEFINITIONNONVIRT(Type)\
Type ## _p Type ## _newTCutG ( const char * name, int  n, double * x, double * y )\
{\
Type * newp = new Type (name, n, x, y); \
return to_nonconst<Type ## _t, Type >(newp);\
}

#undef ROOT_TGRAPHBENTERRORS_DEFINITIONNONVIRT
#define ROOT_TGRAPHBENTERRORS_DEFINITIONNONVIRT(Type)\
Type ## _p Type ## _newTGraphBentErrors ( int  n, double * x, double * y, double * exl, double * exh, double * eyl, double * eyh, double * exld, double * exhd, double * eyld, double * eyhd )\
{\
Type * newp = new Type (n, x, y, exl, exh, eyl, eyh, exld, exhd, eyld, eyhd); \
return to_nonconst<Type ## _t, Type >(newp);\
}

#undef ROOT_TGRAPHERRORS_DEFINITIONNONVIRT
#define ROOT_TGRAPHERRORS_DEFINITIONNONVIRT(Type)\
Type ## _p Type ## _newTGraphErrors ( int  n, double * x, double * y, double * ex, double * ey )\
{\
Type * newp = new Type (n, x, y, ex, ey); \
return to_nonconst<Type ## _t, Type >(newp);\
}

#undef ROOT_TGRAPHPOLAR_DEFINITIONNONVIRT
#define ROOT_TGRAPHPOLAR_DEFINITIONNONVIRT(Type)\
Type ## _p Type ## _newTGraphPolar ( int  n, double * x, double * y, double * ex, double * ey )\
{\
Type * newp = new Type (n, x, y, ex, ey); \
return to_nonconst<Type ## _t, Type >(newp);\
}

#undef ROOT_TGRAPHQQ_DEFINITIONNONVIRT
#define ROOT_TGRAPHQQ_DEFINITIONNONVIRT(Type)\
Type ## _p Type ## _newTGraphQQ ( int  nx, double * x, int  ny, double * y )\
{\
Type * newp = new Type (nx, x, ny, y); \
return to_nonconst<Type ## _t, Type >(newp);\
}

#undef ROOT_TELLIPSE_DEFINITIONNONVIRT
#define ROOT_TELLIPSE_DEFINITIONNONVIRT(Type)\
Type ## _p Type ## _newTEllipse ( double x1, double y1, double r1, double r2, double phimin, double phimax, double theta )\
{\
Type * newp = new Type (x1, y1, r1, r2, phimin, phimax, theta); \
return to_nonconst<Type ## _t, Type >(newp);\
}

#undef ROOT_TARC_DEFINITIONNONVIRT
#define ROOT_TARC_DEFINITIONNONVIRT(Type)\
Type ## _p Type ## _newTArc ( double x1, double y1, double radius, double phimin, double phimax )\
{\
Type * newp = new Type (x1, y1, radius, phimin, phimax); \
return to_nonconst<Type ## _t, Type >(newp);\
}

#undef ROOT_TCROWN_DEFINITIONNONVIRT
#define ROOT_TCROWN_DEFINITIONNONVIRT(Type)\
Type ## _p Type ## _newTCrown ( double x1, double y1, double radin, double radout, double phimin, double phimax )\
{\
Type * newp = new Type (x1, y1, radin, radout, phimin, phimax); \
return to_nonconst<Type ## _t, Type >(newp);\
}

#undef ROOT_TLINE_DEFINITIONNONVIRT
#define ROOT_TLINE_DEFINITIONNONVIRT(Type)\
Type ## _p Type ## _newTLine ( double x1, double y1, double x2, double y2 )\
{\
Type * newp = new Type (x1, y1, x2, y2); \
return to_nonconst<Type ## _t, Type >(newp);\
}

#undef ROOT_TARROW_DEFINITIONNONVIRT
#define ROOT_TARROW_DEFINITIONNONVIRT(Type)\
Type ## _p Type ## _newTArrow ( double x1, double y1, double x2, double y2, double arrowsize, const char * option )\
{\
Type * newp = new Type (x1, y1, x2, y2, arrowsize, option); \
return to_nonconst<Type ## _t, Type >(newp);\
}

#undef ROOT_TGAXIS_DEFINITIONNONVIRT
#define ROOT_TGAXIS_DEFINITIONNONVIRT(Type)\
Type ## _p Type ## _newTGaxis ( double xmin, double ymin, double xmax, double ymax, double wmin, double wmax, int  ndiv, const char * chopt, double gridlength )\
{\
Type * newp = new Type (xmin, ymin, xmax, ymax, wmin, wmax, ndiv, chopt, gridlength); \
return to_nonconst<Type ## _t, Type >(newp);\
}

#undef ROOT_TSHAPE_DEFINITIONNONVIRT
#define ROOT_TSHAPE_DEFINITIONNONVIRT(Type)\
Type ## _p Type ## _newTShape ( const char * name, const char * title, const char * material )\
{\
Type * newp = new Type (name, title, material); \
return to_nonconst<Type ## _t, Type >(newp);\
}

#undef ROOT_TBRIK_DEFINITIONNONVIRT
#define ROOT_TBRIK_DEFINITIONNONVIRT(Type)\
Type ## _p Type ## _newTBRIK ( const char * name, const char * title, const char * material, double dx, double dy, double dz )\
{\
Type * newp = new Type (name, title, material, dx, dy, dz); \
return to_nonconst<Type ## _t, Type >(newp);\
}

#undef ROOT_TTUBE_DEFINITIONNONVIRT
#define ROOT_TTUBE_DEFINITIONNONVIRT(Type)\
Type ## _p Type ## _newTTUBE ( const char * name, const char * title, const char * material, double rmin, double rmax, double dz, double aspect )\
{\
Type * newp = new Type (name, title, material, rmin, rmax, dz, aspect); \
return to_nonconst<Type ## _t, Type >(newp);\
}

#undef ROOT_TPCON_DEFINITIONNONVIRT
#define ROOT_TPCON_DEFINITIONNONVIRT(Type)\
Type ## _p Type ## _newTPCON ( const char * name, const char * title, const char * material, double phi1, double dphi1, int  nz )\
{\
Type * newp = new Type (name, title, material, phi1, dphi1, nz); \
return to_nonconst<Type ## _t, Type >(newp);\
}

#undef ROOT_TSPHE_DEFINITIONNONVIRT
#define ROOT_TSPHE_DEFINITIONNONVIRT(Type)\
Type ## _p Type ## _newTSPHE ( const char * name, const char * title, const char * material, double rmin, double rmax, double themin, double themax, double phimin, double phimax )\
{\
Type * newp = new Type (name, title, material, rmin, rmax, themin, themax, phimin, phimax); \
return to_nonconst<Type ## _t, Type >(newp);\
}

#undef ROOT_TXTRU_DEFINITIONNONVIRT
#define ROOT_TXTRU_DEFINITIONNONVIRT(Type)\
Type ## _p Type ## _newTXTRU ( const char * name, const char * title, const char * material, int  nyx, int  nz )\
{\
Type * newp = new Type (name, title, material, nyx, nz); \
return to_nonconst<Type ## _t, Type >(newp);\
}

#undef ROOT_TBOX_DEFINITIONNONVIRT
#define ROOT_TBOX_DEFINITIONNONVIRT(Type)\
Type ## _p Type ## _newTBox ( double x1, double y1, double x2, double y2 )\
{\
Type * newp = new Type (x1, y1, x2, y2); \
return to_nonconst<Type ## _t, Type >(newp);\
}

#undef ROOT_TPAVE_DEFINITIONNONVIRT
#define ROOT_TPAVE_DEFINITIONNONVIRT(Type)\
Type ## _p Type ## _newTPave ( double x1, double y1, double x2, double y2, int  bordersize, const char * br )\
{\
Type * newp = new Type (x1, y1, x2, y2, bordersize, br); \
return to_nonconst<Type ## _t, Type >(newp);\
}

#undef ROOT_TPAVETEXT_DEFINITIONNONVIRT
#define ROOT_TPAVETEXT_DEFINITIONNONVIRT(Type)\
Type ## _p Type ## _newTPaveText ( double x1, double y1, double x2, double y2, const char * br )\
{\
Type * newp = new Type (x1, y1, x2, y2, br); \
return to_nonconst<Type ## _t, Type >(newp);\
}

#undef ROOT_TDIAMOND_DEFINITIONNONVIRT
#define ROOT_TDIAMOND_DEFINITIONNONVIRT(Type)\
Type ## _p Type ## _newTDiamond ( double x1, double y1, double x2, double y2 )\
{\
Type * newp = new Type (x1, y1, x2, y2); \
return to_nonconst<Type ## _t, Type >(newp);\
}

#undef ROOT_TPAVESTATS_DEFINITIONNONVIRT
#define ROOT_TPAVESTATS_DEFINITIONNONVIRT(Type)\
Type ## _p Type ## _newTPaveStats ( double x1, double y1, double x2, double y2, const char * br )\
{\
Type * newp = new Type (x1, y1, x2, y2, br); \
return to_nonconst<Type ## _t, Type >(newp);\
}

#undef ROOT_TPAVESTEXT_DEFINITIONNONVIRT
#define ROOT_TPAVESTEXT_DEFINITIONNONVIRT(Type)\
Type ## _p Type ## _newTPavesText ( double x1, double y1, double x2, double y2, int  npaves, const char * br )\
{\
Type * newp = new Type (x1, y1, x2, y2, npaves, br); \
return to_nonconst<Type ## _t, Type >(newp);\
}

#undef ROOT_TLEGEND_DEFINITIONNONVIRT
#define ROOT_TLEGEND_DEFINITIONNONVIRT(Type)\
Type ## _p Type ## _newTLegend ( double x1, double y1, double x2, double y2, const char * header, const char * option )\
{\
Type * newp = new Type (x1, y1, x2, y2, header, option); \
return to_nonconst<Type ## _t, Type >(newp);\
}

#undef ROOT_TPAVELABEL_DEFINITIONNONVIRT
#define ROOT_TPAVELABEL_DEFINITIONNONVIRT(Type)\
Type ## _p Type ## _newTPaveLabel ( double x1, double y1, double x2, double y2, const char * label, const char * option )\
{\
Type * newp = new Type (x1, y1, x2, y2, label, option); \
return to_nonconst<Type ## _t, Type >(newp);\
}

#undef ROOT_TPAVECLASS_DEFINITIONNONVIRT
#define ROOT_TPAVECLASS_DEFINITIONNONVIRT(Type)\


#undef ROOT_TWBOX_DEFINITIONNONVIRT
#define ROOT_TWBOX_DEFINITIONNONVIRT(Type)\
Type ## _p Type ## _newTWbox ( double x1, double y1, double x2, double y2, int  color, int  bordersize, int  bordermode )\
{\
Type * newp = new Type (x1, y1, x2, y2, color, bordersize, bordermode); \
return to_nonconst<Type ## _t, Type >(newp);\
}

#undef ROOT_TFRAME_DEFINITIONNONVIRT
#define ROOT_TFRAME_DEFINITIONNONVIRT(Type)\
Type ## _p Type ## _newTFrame ( double x1, double y1, double x2, double y2 )\
{\
Type * newp = new Type (x1, y1, x2, y2); \
return to_nonconst<Type ## _t, Type >(newp);\
}

#undef ROOT_TSLIDERBOX_DEFINITIONNONVIRT
#define ROOT_TSLIDERBOX_DEFINITIONNONVIRT(Type)\
Type ## _p Type ## _newTSliderBox ( double x1, double y1, double x2, double y2, int  color, int  bordersize, int  bordermode )\
{\
Type * newp = new Type (x1, y1, x2, y2, color, bordersize, bordermode); \
return to_nonconst<Type ## _t, Type >(newp);\
}

#undef ROOT_TTREE_DEFINITIONNONVIRT
#define ROOT_TTREE_DEFINITIONNONVIRT(Type)\
Type ## _p Type ## _newTTree ( const char * name, const char * title, int  splitlevel )\
{\
Type * newp = new Type (name, title, splitlevel); \
return to_nonconst<Type ## _t, Type >(newp);\
}

#undef ROOT_TCHAIN_DEFINITIONNONVIRT
#define ROOT_TCHAIN_DEFINITIONNONVIRT(Type)\
Type ## _p Type ## _newTChain ( const char * name, const char * title )\
{\
Type * newp = new Type (name, title); \
return to_nonconst<Type ## _t, Type >(newp);\
}

#undef ROOT_TNTUPLE_DEFINITIONNONVIRT
#define ROOT_TNTUPLE_DEFINITIONNONVIRT(Type)\
Type ## _p Type ## _newTNtuple ( const char * name, const char * title, const char * varlist, int  bufsize )\
{\
Type * newp = new Type (name, title, varlist, bufsize); \
return to_nonconst<Type ## _t, Type >(newp);\
}

#undef ROOT_TNTUPLED_DEFINITIONNONVIRT
#define ROOT_TNTUPLED_DEFINITIONNONVIRT(Type)\
Type ## _p Type ## _newTNtupleD ( const char * name, const char * title, const char * varlist, int  bufsize )\
{\
Type * newp = new Type (name, title, varlist, bufsize); \
return to_nonconst<Type ## _t, Type >(newp);\
}

#undef ROOT_TTREESQL_DEFINITIONNONVIRT
#define ROOT_TTREESQL_DEFINITIONNONVIRT(Type)\


#undef ROOT_TPOLYLINE_DEFINITIONNONVIRT
#define ROOT_TPOLYLINE_DEFINITIONNONVIRT(Type)\
Type ## _p Type ## _newTPolyLine ( int  n, double * x, double * y, const char * option )\
{\
Type * newp = new Type (n, x, y, option); \
return to_nonconst<Type ## _t, Type >(newp);\
}

#undef ROOT_TCURLYLINE_DEFINITIONNONVIRT
#define ROOT_TCURLYLINE_DEFINITIONNONVIRT(Type)\
Type ## _p Type ## _newTCurlyLine ( double x1, double y1, double x2, double y2, double wl, double amp )\
{\
Type * newp = new Type (x1, y1, x2, y2, wl, amp); \
return to_nonconst<Type ## _t, Type >(newp);\
}

#undef ROOT_TCURLYARC_DEFINITIONNONVIRT
#define ROOT_TCURLYARC_DEFINITIONNONVIRT(Type)\
Type ## _p Type ## _newTCurlyArc ( double x1, double y1, double rad, double phimin, double phimax, double wl, double amp )\
{\
Type * newp = new Type (x1, y1, rad, phimin, phimax, wl, amp); \
return to_nonconst<Type ## _t, Type >(newp);\
}

#undef ROOT_TEFFICIENCY_DEFINITIONNONVIRT
#define ROOT_TEFFICIENCY_DEFINITIONNONVIRT(Type)\


#undef ROOT_TAXIS_DEFINITIONNONVIRT
#define ROOT_TAXIS_DEFINITIONNONVIRT(Type)\
Type ## _p Type ## _newTAxis ( int  nbins, double xmin, double xmax )\
{\
Type * newp = new Type (nbins, xmin, xmax); \
return to_nonconst<Type ## _t, Type >(newp);\
}

#undef ROOT_TLATEX_DEFINITIONNONVIRT
#define ROOT_TLATEX_DEFINITIONNONVIRT(Type)\
Type ## _p Type ## _newTLatex ( double x, double y, const char * text )\
{\
Type * newp = new Type (x, y, text); \
return to_nonconst<Type ## _t, Type >(newp);\
}\
Type ## _p Type ## _tLatexDrawLatex ( Type ## _p p, double x, double y, const char * text )\
{\
return to_nonconst<Type ## _t, Type>((Type *)to_nonconst<Type,Type ## _t>(p)->DrawLatex(x, y, text)) ;\
}

#undef ROOT_TTEXT_DEFINITIONNONVIRT
#define ROOT_TTEXT_DEFINITIONNONVIRT(Type)\


#undef ROOT_TDIRECTORY_DEFINITIONNONVIRT
#define ROOT_TDIRECTORY_DEFINITIONNONVIRT(Type)\


#undef ROOT_TDIRECTORYFILE_DEFINITIONNONVIRT
#define ROOT_TDIRECTORYFILE_DEFINITIONNONVIRT(Type)\


#undef ROOT_TFILE_DEFINITIONNONVIRT
#define ROOT_TFILE_DEFINITIONNONVIRT(Type)\
Type ## _p Type ## _newTFile ( const char * fname, const char * option, const char * ftitle, int  compress )\
{\
Type * newp = new Type (fname, option, ftitle, compress); \
return to_nonconst<Type ## _t, Type >(newp);\
}

#undef ROOT_TBRANCH_DEFINITIONNONVIRT
#define ROOT_TBRANCH_DEFINITIONNONVIRT(Type)\


#undef ROOT_TVIRTUALTREEPLAYER_DEFINITIONNONVIRT
#define ROOT_TVIRTUALTREEPLAYER_DEFINITIONNONVIRT(Type)\


#undef ROOT_TTREEPLAYER_DEFINITIONNONVIRT
#define ROOT_TTREEPLAYER_DEFINITIONNONVIRT(Type)\


#undef ROOT_TARRAY_DEFINITIONNONVIRT
#define ROOT_TARRAY_DEFINITIONNONVIRT(Type)\


#undef ROOT_TARRAYC_DEFINITIONNONVIRT
#define ROOT_TARRAYC_DEFINITIONNONVIRT(Type)\


#undef ROOT_TARRAYD_DEFINITIONNONVIRT
#define ROOT_TARRAYD_DEFINITIONNONVIRT(Type)\


#undef ROOT_TARRAYF_DEFINITIONNONVIRT
#define ROOT_TARRAYF_DEFINITIONNONVIRT(Type)\


#undef ROOT_TARRAYI_DEFINITIONNONVIRT
#define ROOT_TARRAYI_DEFINITIONNONVIRT(Type)\


#undef ROOT_TARRAYL_DEFINITIONNONVIRT
#define ROOT_TARRAYL_DEFINITIONNONVIRT(Type)\


#undef ROOT_TARRAYL64_DEFINITIONNONVIRT
#define ROOT_TARRAYL64_DEFINITIONNONVIRT(Type)\


#undef ROOT_TARRAYS_DEFINITIONNONVIRT
#define ROOT_TARRAYS_DEFINITIONNONVIRT(Type)\


#undef ROOT_TH1_DEFINITIONNONVIRT
#define ROOT_TH1_DEFINITIONNONVIRT(Type)\
Type ## _p Type ## _tH1GetAsymmetry ( Type ## _p p, TH1_p h2, double c2, double dc2 )\
{\
return to_nonconst<Type ## _t, Type>((Type *)to_nonconst<Type,Type ## _t>(p)->GetAsymmetry(to_nonconst<TH1,TH1_t>(h2), c2, dc2)) ;\
}\
int  Type ## _tH1GetBufferLength ( Type ## _p p )\
{\
return to_nonconst<Type,Type ## _t>(p)->GetBufferLength();\
}\
int  Type ## _tH1GetBufferSize ( Type ## _p p )\
{\
return to_nonconst<Type,Type ## _t>(p)->GetBufferSize();\
}\
TDirectory_p Type ## _tH1GetDirectory ( Type ## _p p )\
{\
return to_nonconst<TDirectory_t,TDirectory>((TDirectory*)to_nonconst<Type,Type ## _t>(p)->GetDirectory());\
}\
TAxis_p Type ## _tH1GetXaxis ( Type ## _p p )\
{\
return to_nonconst<TAxis_t,TAxis>((TAxis*)to_nonconst<Type,Type ## _t>(p)->GetXaxis());\
}\
TAxis_p Type ## _tH1GetYaxis ( Type ## _p p )\
{\
return to_nonconst<TAxis_t,TAxis>((TAxis*)to_nonconst<Type,Type ## _t>(p)->GetYaxis());\
}\
TAxis_p Type ## _tH1GetZaxis ( Type ## _p p )\
{\
return to_nonconst<TAxis_t,TAxis>((TAxis*)to_nonconst<Type,Type ## _t>(p)->GetZaxis());\
}

#undef ROOT_TH2_DEFINITIONNONVIRT
#define ROOT_TH2_DEFINITIONNONVIRT(Type)\
TH1D_p Type ## _tH2ProjectionX ( Type ## _p p, const char * name, int  firstybin, int  lastybin, const char * option )\
{\
return to_nonconst<TH1D_t,TH1D>((TH1D*)to_nonconst<Type,Type ## _t>(p)->ProjectionX(name, firstybin, lastybin, option));\
}\
TH1D_p Type ## _tH2ProjectionY ( Type ## _p p, const char * name, int  firstxbin, int  lastxbin, const char * option )\
{\
return to_nonconst<TH1D_t,TH1D>((TH1D*)to_nonconst<Type,Type ## _t>(p)->ProjectionY(name, firstxbin, lastxbin, option));\
}

#undef ROOT_TH3_DEFINITIONNONVIRT
#define ROOT_TH3_DEFINITIONNONVIRT(Type)\


#undef ROOT_TH1C_DEFINITIONNONVIRT
#define ROOT_TH1C_DEFINITIONNONVIRT(Type)\


#undef ROOT_TH1D_DEFINITIONNONVIRT
#define ROOT_TH1D_DEFINITIONNONVIRT(Type)\


#undef ROOT_TH1F_DEFINITIONNONVIRT
#define ROOT_TH1F_DEFINITIONNONVIRT(Type)\
Type ## _p Type ## _newTH1F ( const char * name, const char * title, int  nbinsx, double xlow, double xup )\
{\
Type * newp = new Type (name, title, nbinsx, xlow, xup); \
return to_nonconst<Type ## _t, Type >(newp);\
}

#undef ROOT_TH1I_DEFINITIONNONVIRT
#define ROOT_TH1I_DEFINITIONNONVIRT(Type)\


#undef ROOT_TH1S_DEFINITIONNONVIRT
#define ROOT_TH1S_DEFINITIONNONVIRT(Type)\


#undef ROOT_TH2C_DEFINITIONNONVIRT
#define ROOT_TH2C_DEFINITIONNONVIRT(Type)\


#undef ROOT_TH2D_DEFINITIONNONVIRT
#define ROOT_TH2D_DEFINITIONNONVIRT(Type)\
Type ## _p Type ## _newTH2D ( const char * name, const char * title, int  nbinsx, double xlow, double xup, int  nbinsy, double ylow, double yup )\
{\
Type * newp = new Type (name, title, nbinsx, xlow, xup, nbinsy, ylow, yup); \
return to_nonconst<Type ## _t, Type >(newp);\
}

#undef ROOT_TH2F_DEFINITIONNONVIRT
#define ROOT_TH2F_DEFINITIONNONVIRT(Type)\
Type ## _p Type ## _newTH2F ( const char * name, const char * title, int  nbinsx, double xlow, double xup, int  nbinsy, double ylow, double yup )\
{\
Type * newp = new Type (name, title, nbinsx, xlow, xup, nbinsy, ylow, yup); \
return to_nonconst<Type ## _t, Type >(newp);\
}

#undef ROOT_TH2I_DEFINITIONNONVIRT
#define ROOT_TH2I_DEFINITIONNONVIRT(Type)\


#undef ROOT_TH2POLY_DEFINITIONNONVIRT
#define ROOT_TH2POLY_DEFINITIONNONVIRT(Type)\


#undef ROOT_TH2S_DEFINITIONNONVIRT
#define ROOT_TH2S_DEFINITIONNONVIRT(Type)\


#undef ROOT_TH3C_DEFINITIONNONVIRT
#define ROOT_TH3C_DEFINITIONNONVIRT(Type)\


#undef ROOT_TH3D_DEFINITIONNONVIRT
#define ROOT_TH3D_DEFINITIONNONVIRT(Type)\


#undef ROOT_TH3F_DEFINITIONNONVIRT
#define ROOT_TH3F_DEFINITIONNONVIRT(Type)\


#undef ROOT_TH3I_DEFINITIONNONVIRT
#define ROOT_TH3I_DEFINITIONNONVIRT(Type)\


#undef ROOT_TH3S_DEFINITIONNONVIRT
#define ROOT_TH3S_DEFINITIONNONVIRT(Type)\


#undef ROOT_TQOBJECT_DEFINITIONNONVIRT
#define ROOT_TQOBJECT_DEFINITIONNONVIRT(Type)\


#undef ROOT_TVIRTUALPAD_DEFINITIONNONVIRT
#define ROOT_TVIRTUALPAD_DEFINITIONNONVIRT(Type)\


#undef ROOT_TPAD_DEFINITIONNONVIRT
#define ROOT_TPAD_DEFINITIONNONVIRT(Type)\


#undef ROOT_TBUTTON_DEFINITIONNONVIRT
#define ROOT_TBUTTON_DEFINITIONNONVIRT(Type)\


#undef ROOT_TGROUPBUTTON_DEFINITIONNONVIRT
#define ROOT_TGROUPBUTTON_DEFINITIONNONVIRT(Type)\


#undef ROOT_TCANVAS_DEFINITIONNONVIRT
#define ROOT_TCANVAS_DEFINITIONNONVIRT(Type)\
Type ## _p Type ## _newTCanvas ( const char * name, const char * title, int  ww, int  wh )\
{\
Type * newp = new Type (name, title, ww, wh); \
return to_nonconst<Type ## _t, Type >(newp);\
}

#undef ROOT_TDIALOGCANVAS_DEFINITIONNONVIRT
#define ROOT_TDIALOGCANVAS_DEFINITIONNONVIRT(Type)\


#undef ROOT_TINSPECTCANVAS_DEFINITIONNONVIRT
#define ROOT_TINSPECTCANVAS_DEFINITIONNONVIRT(Type)\


#undef ROOT_TEVEPAD_DEFINITIONNONVIRT
#define ROOT_TEVEPAD_DEFINITIONNONVIRT(Type)\


#undef ROOT_TSLIDER_DEFINITIONNONVIRT
#define ROOT_TSLIDER_DEFINITIONNONVIRT(Type)\


#undef ROOT_TAPPLICATION_DEFINITIONNONVIRT
#define ROOT_TAPPLICATION_DEFINITIONNONVIRT(Type)\
Type ## _p Type ## _newTApplication ( const char * appClassName, int * argc, char ** argv )\
{\
Type * newp = new Type (appClassName, argc, argv); \
return to_nonconst<Type ## _t, Type >(newp);\
}

#undef ROOT_TRINT_DEFINITIONNONVIRT
#define ROOT_TRINT_DEFINITIONNONVIRT(Type)\
Type ## _p Type ## _newTRint ( const char * appClassName, int * argc, char ** argv )\
{\
Type * newp = new Type (appClassName, argc, argv); \
return to_nonconst<Type ## _t, Type >(newp);\
}

#undef ROOT_TRANDOM_DEFINITIONNONVIRT
#define ROOT_TRANDOM_DEFINITIONNONVIRT(Type)\
Type ## _p Type ## _newTRandom ( int  seed )\
{\
Type * newp = new Type (seed); \
return to_nonconst<Type ## _t, Type >(newp);\
}

#undef ROOT_TCOLLECTION_DEFINITIONNONVIRT
#define ROOT_TCOLLECTION_DEFINITIONNONVIRT(Type)\


#undef ROOT_TSEQCOLLECTION_DEFINITIONNONVIRT
#define ROOT_TSEQCOLLECTION_DEFINITIONNONVIRT(Type)\


#undef ROOT_TOBJARRAY_DEFINITIONNONVIRT
#define ROOT_TOBJARRAY_DEFINITIONNONVIRT(Type)\


ROOT_DELETABLE_DEFINITIONVIRT(TObjArray)
ROOT_DELETABLE_DEFINITIONVIRT(TSeqCollection)
ROOT_DELETABLE_DEFINITIONVIRT(TCollection)
ROOT_DELETABLE_DEFINITIONVIRT(TRandom)
ROOT_DELETABLE_DEFINITIONVIRT(TRint)
ROOT_DELETABLE_DEFINITIONVIRT(TApplication)
ROOT_DELETABLE_DEFINITIONVIRT(TSlider)
ROOT_DELETABLE_DEFINITIONVIRT(TEvePad)
ROOT_DELETABLE_DEFINITIONVIRT(TInspectCanvas)
ROOT_DELETABLE_DEFINITIONVIRT(TDialogCanvas)
ROOT_DELETABLE_DEFINITIONVIRT(TCanvas)
ROOT_DELETABLE_DEFINITIONVIRT(TGroupButton)
ROOT_DELETABLE_DEFINITIONVIRT(TButton)
ROOT_DELETABLE_DEFINITIONVIRT(TPad)
ROOT_DELETABLE_DEFINITIONVIRT(TVirtualPad)
ROOT_DELETABLE_DEFINITIONVIRT(TQObject)
ROOT_DELETABLE_DEFINITIONVIRT(TH3S)
ROOT_DELETABLE_DEFINITIONVIRT(TH3I)
ROOT_DELETABLE_DEFINITIONVIRT(TH3F)
ROOT_DELETABLE_DEFINITIONVIRT(TH3D)
ROOT_DELETABLE_DEFINITIONVIRT(TH3C)
ROOT_DELETABLE_DEFINITIONVIRT(TH2S)
ROOT_DELETABLE_DEFINITIONVIRT(TH2Poly)
ROOT_DELETABLE_DEFINITIONVIRT(TH2I)
ROOT_DELETABLE_DEFINITIONVIRT(TH2F)
ROOT_DELETABLE_DEFINITIONVIRT(TH2D)
ROOT_DELETABLE_DEFINITIONVIRT(TH2C)
ROOT_DELETABLE_DEFINITIONVIRT(TH1S)
ROOT_DELETABLE_DEFINITIONVIRT(TH1I)
ROOT_DELETABLE_DEFINITIONVIRT(TH1F)
ROOT_DELETABLE_DEFINITIONVIRT(TH1D)
ROOT_DELETABLE_DEFINITIONVIRT(TH1C)
ROOT_DELETABLE_DEFINITIONVIRT(TH3)
ROOT_DELETABLE_DEFINITIONVIRT(TH2)
ROOT_DELETABLE_DEFINITIONVIRT(TH1)
ROOT_DELETABLE_DEFINITIONVIRT(TArrayS)
ROOT_DELETABLE_DEFINITIONVIRT(TArrayL64)
ROOT_DELETABLE_DEFINITIONVIRT(TArrayL)
ROOT_DELETABLE_DEFINITIONVIRT(TArrayI)
ROOT_DELETABLE_DEFINITIONVIRT(TArrayF)
ROOT_DELETABLE_DEFINITIONVIRT(TArrayD)
ROOT_DELETABLE_DEFINITIONVIRT(TArrayC)
ROOT_DELETABLE_DEFINITIONVIRT(TArray)
ROOT_DELETABLE_DEFINITIONVIRT(TTreePlayer)
ROOT_DELETABLE_DEFINITIONVIRT(TVirtualTreePlayer)
ROOT_DELETABLE_DEFINITIONVIRT(TBranch)
ROOT_DELETABLE_DEFINITIONVIRT(TFile)
ROOT_DELETABLE_DEFINITIONVIRT(TDirectoryFile)
ROOT_DELETABLE_DEFINITIONVIRT(TDirectory)
ROOT_DELETABLE_DEFINITIONVIRT(TText)
ROOT_DELETABLE_DEFINITIONVIRT(TLatex)
ROOT_DELETABLE_DEFINITIONVIRT(TAxis)
ROOT_DELETABLE_DEFINITIONVIRT(TEfficiency)
ROOT_DELETABLE_DEFINITIONVIRT(TCurlyArc)
ROOT_DELETABLE_DEFINITIONVIRT(TCurlyLine)
ROOT_DELETABLE_DEFINITIONVIRT(TPolyLine)
ROOT_DELETABLE_DEFINITIONVIRT(TTreeSQL)
ROOT_DELETABLE_DEFINITIONVIRT(TNtupleD)
ROOT_DELETABLE_DEFINITIONVIRT(TNtuple)
ROOT_DELETABLE_DEFINITIONVIRT(TChain)
ROOT_DELETABLE_DEFINITIONVIRT(TTree)
ROOT_DELETABLE_DEFINITIONVIRT(TSliderBox)
ROOT_DELETABLE_DEFINITIONVIRT(TFrame)
ROOT_DELETABLE_DEFINITIONVIRT(TWbox)
ROOT_DELETABLE_DEFINITIONVIRT(TPaveClass)
ROOT_DELETABLE_DEFINITIONVIRT(TPaveLabel)
ROOT_DELETABLE_DEFINITIONVIRT(TLegend)
ROOT_DELETABLE_DEFINITIONVIRT(TPavesText)
ROOT_DELETABLE_DEFINITIONVIRT(TPaveStats)
ROOT_DELETABLE_DEFINITIONVIRT(TDiamond)
ROOT_DELETABLE_DEFINITIONVIRT(TPaveText)
ROOT_DELETABLE_DEFINITIONVIRT(TPave)
ROOT_DELETABLE_DEFINITIONVIRT(TBox)
ROOT_DELETABLE_DEFINITIONVIRT(TXTRU)
ROOT_DELETABLE_DEFINITIONVIRT(TSPHE)
ROOT_DELETABLE_DEFINITIONVIRT(TPCON)
ROOT_DELETABLE_DEFINITIONVIRT(TTUBE)
ROOT_DELETABLE_DEFINITIONVIRT(TBRIK)
ROOT_DELETABLE_DEFINITIONVIRT(TShape)
ROOT_DELETABLE_DEFINITIONVIRT(TGaxis)
ROOT_DELETABLE_DEFINITIONVIRT(TArrow)
ROOT_DELETABLE_DEFINITIONVIRT(TLine)
ROOT_DELETABLE_DEFINITIONVIRT(TCrown)
ROOT_DELETABLE_DEFINITIONVIRT(TArc)
ROOT_DELETABLE_DEFINITIONVIRT(TEllipse)
ROOT_DELETABLE_DEFINITIONVIRT(TGraphQQ)
ROOT_DELETABLE_DEFINITIONVIRT(TGraphPolar)
ROOT_DELETABLE_DEFINITIONVIRT(TGraphErrors)
ROOT_DELETABLE_DEFINITIONVIRT(TGraphBentErrors)
ROOT_DELETABLE_DEFINITIONVIRT(TCutG)
ROOT_DELETABLE_DEFINITIONVIRT(TGraphAsymmErrors)
ROOT_DELETABLE_DEFINITIONVIRT(TGraph)
ROOT_DELETABLE_DEFINITIONVIRT(TF1)
ROOT_DELETABLE_DEFINITIONVIRT(THStack)
ROOT_DELETABLE_DEFINITIONVIRT(TAttText)
ROOT_DELETABLE_DEFINITIONVIRT(TAttParticle)
ROOT_DELETABLE_DEFINITIONVIRT(TAttPad)
ROOT_DELETABLE_DEFINITIONVIRT(TAttMarker)
ROOT_DELETABLE_DEFINITIONVIRT(TAttLine)
ROOT_DELETABLE_DEFINITIONVIRT(TAttImage)
ROOT_DELETABLE_DEFINITIONVIRT(TAttFill)
ROOT_DELETABLE_DEFINITIONVIRT(TAttCanvas)
ROOT_DELETABLE_DEFINITIONVIRT(TAttBBox)
ROOT_DELETABLE_DEFINITIONVIRT(TAttAxis)
ROOT_DELETABLE_DEFINITIONVIRT(TAtt3D)
ROOT_DELETABLE_DEFINITIONVIRT(TFormula)
ROOT_DELETABLE_DEFINITIONVIRT(TClass)
ROOT_DELETABLE_DEFINITIONVIRT(TNamed)
ROOT_DELETABLE_DEFINITIONVIRT(TObject)
ROOT_TAPPLICATION_DEFINITIONVIRT(TRint)
ROOT_TAPPLICATION_DEFINITIONVIRT(TApplication)
ROOT_TARC_DEFINITIONVIRT(TArc)
ROOT_TARRAY_DEFINITIONVIRT(TH3S)
ROOT_TARRAY_DEFINITIONVIRT(TH3I)
ROOT_TARRAY_DEFINITIONVIRT(TH3F)
ROOT_TARRAY_DEFINITIONVIRT(TH3D)
ROOT_TARRAY_DEFINITIONVIRT(TH3C)
ROOT_TARRAY_DEFINITIONVIRT(TH2S)
ROOT_TARRAY_DEFINITIONVIRT(TH2I)
ROOT_TARRAY_DEFINITIONVIRT(TH2F)
ROOT_TARRAY_DEFINITIONVIRT(TH2D)
ROOT_TARRAY_DEFINITIONVIRT(TH2C)
ROOT_TARRAY_DEFINITIONVIRT(TH1S)
ROOT_TARRAY_DEFINITIONVIRT(TH1I)
ROOT_TARRAY_DEFINITIONVIRT(TH1F)
ROOT_TARRAY_DEFINITIONVIRT(TH1D)
ROOT_TARRAY_DEFINITIONVIRT(TH1C)
ROOT_TARRAY_DEFINITIONVIRT(TArrayS)
ROOT_TARRAY_DEFINITIONVIRT(TArrayL64)
ROOT_TARRAY_DEFINITIONVIRT(TArrayL)
ROOT_TARRAY_DEFINITIONVIRT(TArrayI)
ROOT_TARRAY_DEFINITIONVIRT(TArrayF)
ROOT_TARRAY_DEFINITIONVIRT(TArrayD)
ROOT_TARRAY_DEFINITIONVIRT(TArrayC)
ROOT_TARRAY_DEFINITIONVIRT(TArray)
ROOT_TARRAYC_DEFINITIONVIRT(TH3C)
ROOT_TARRAYC_DEFINITIONVIRT(TH2C)
ROOT_TARRAYC_DEFINITIONVIRT(TH1C)
ROOT_TARRAYC_DEFINITIONVIRT(TArrayC)
ROOT_TARRAYD_DEFINITIONVIRT(TH3D)
ROOT_TARRAYD_DEFINITIONVIRT(TH2D)
ROOT_TARRAYD_DEFINITIONVIRT(TH1D)
ROOT_TARRAYD_DEFINITIONVIRT(TArrayD)
ROOT_TARRAYF_DEFINITIONVIRT(TH3F)
ROOT_TARRAYF_DEFINITIONVIRT(TH2F)
ROOT_TARRAYF_DEFINITIONVIRT(TH1F)
ROOT_TARRAYF_DEFINITIONVIRT(TArrayF)
ROOT_TARRAYI_DEFINITIONVIRT(TH3I)
ROOT_TARRAYI_DEFINITIONVIRT(TH2I)
ROOT_TARRAYI_DEFINITIONVIRT(TH1I)
ROOT_TARRAYI_DEFINITIONVIRT(TArrayI)
ROOT_TARRAYL_DEFINITIONVIRT(TArrayL)
ROOT_TARRAYL64_DEFINITIONVIRT(TArrayL64)
ROOT_TARRAYS_DEFINITIONVIRT(TH3S)
ROOT_TARRAYS_DEFINITIONVIRT(TH2S)
ROOT_TARRAYS_DEFINITIONVIRT(TH1S)
ROOT_TARRAYS_DEFINITIONVIRT(TArrayS)
ROOT_TARROW_DEFINITIONVIRT(TArrow)
ROOT_TATT3D_DEFINITIONVIRT(TH3S)
ROOT_TATT3D_DEFINITIONVIRT(TH3I)
ROOT_TATT3D_DEFINITIONVIRT(TH3F)
ROOT_TATT3D_DEFINITIONVIRT(TH3D)
ROOT_TATT3D_DEFINITIONVIRT(TH3C)
ROOT_TATT3D_DEFINITIONVIRT(TH3)
ROOT_TATT3D_DEFINITIONVIRT(TXTRU)
ROOT_TATT3D_DEFINITIONVIRT(TSPHE)
ROOT_TATT3D_DEFINITIONVIRT(TPCON)
ROOT_TATT3D_DEFINITIONVIRT(TTUBE)
ROOT_TATT3D_DEFINITIONVIRT(TBRIK)
ROOT_TATT3D_DEFINITIONVIRT(TShape)
ROOT_TATT3D_DEFINITIONVIRT(TAtt3D)
ROOT_TATTAXIS_DEFINITIONVIRT(TAxis)
ROOT_TATTAXIS_DEFINITIONVIRT(TAttAxis)
ROOT_TATTBBOX_DEFINITIONVIRT(TAttBBox)
ROOT_TATTCANVAS_DEFINITIONVIRT(TAttCanvas)
ROOT_TATTFILL_DEFINITIONVIRT(TSlider)
ROOT_TATTFILL_DEFINITIONVIRT(TEvePad)
ROOT_TATTFILL_DEFINITIONVIRT(TInspectCanvas)
ROOT_TATTFILL_DEFINITIONVIRT(TDialogCanvas)
ROOT_TATTFILL_DEFINITIONVIRT(TCanvas)
ROOT_TATTFILL_DEFINITIONVIRT(TGroupButton)
ROOT_TATTFILL_DEFINITIONVIRT(TButton)
ROOT_TATTFILL_DEFINITIONVIRT(TPad)
ROOT_TATTFILL_DEFINITIONVIRT(TVirtualPad)
ROOT_TATTFILL_DEFINITIONVIRT(TH3S)
ROOT_TATTFILL_DEFINITIONVIRT(TH3I)
ROOT_TATTFILL_DEFINITIONVIRT(TH3F)
ROOT_TATTFILL_DEFINITIONVIRT(TH3D)
ROOT_TATTFILL_DEFINITIONVIRT(TH3C)
ROOT_TATTFILL_DEFINITIONVIRT(TH2S)
ROOT_TATTFILL_DEFINITIONVIRT(TH2Poly)
ROOT_TATTFILL_DEFINITIONVIRT(TH2I)
ROOT_TATTFILL_DEFINITIONVIRT(TH2F)
ROOT_TATTFILL_DEFINITIONVIRT(TH2D)
ROOT_TATTFILL_DEFINITIONVIRT(TH2C)
ROOT_TATTFILL_DEFINITIONVIRT(TH1S)
ROOT_TATTFILL_DEFINITIONVIRT(TH1I)
ROOT_TATTFILL_DEFINITIONVIRT(TH1F)
ROOT_TATTFILL_DEFINITIONVIRT(TH1D)
ROOT_TATTFILL_DEFINITIONVIRT(TH1C)
ROOT_TATTFILL_DEFINITIONVIRT(TH3)
ROOT_TATTFILL_DEFINITIONVIRT(TH2)
ROOT_TATTFILL_DEFINITIONVIRT(TH1)
ROOT_TATTFILL_DEFINITIONVIRT(TBranch)
ROOT_TATTFILL_DEFINITIONVIRT(TEfficiency)
ROOT_TATTFILL_DEFINITIONVIRT(TCurlyArc)
ROOT_TATTFILL_DEFINITIONVIRT(TCurlyLine)
ROOT_TATTFILL_DEFINITIONVIRT(TPolyLine)
ROOT_TATTFILL_DEFINITIONVIRT(TTreeSQL)
ROOT_TATTFILL_DEFINITIONVIRT(TNtupleD)
ROOT_TATTFILL_DEFINITIONVIRT(TNtuple)
ROOT_TATTFILL_DEFINITIONVIRT(TChain)
ROOT_TATTFILL_DEFINITIONVIRT(TTree)
ROOT_TATTFILL_DEFINITIONVIRT(TSliderBox)
ROOT_TATTFILL_DEFINITIONVIRT(TFrame)
ROOT_TATTFILL_DEFINITIONVIRT(TWbox)
ROOT_TATTFILL_DEFINITIONVIRT(TPaveClass)
ROOT_TATTFILL_DEFINITIONVIRT(TPaveLabel)
ROOT_TATTFILL_DEFINITIONVIRT(TLegend)
ROOT_TATTFILL_DEFINITIONVIRT(TPavesText)
ROOT_TATTFILL_DEFINITIONVIRT(TPaveStats)
ROOT_TATTFILL_DEFINITIONVIRT(TDiamond)
ROOT_TATTFILL_DEFINITIONVIRT(TPaveText)
ROOT_TATTFILL_DEFINITIONVIRT(TPave)
ROOT_TATTFILL_DEFINITIONVIRT(TBox)
ROOT_TATTFILL_DEFINITIONVIRT(TXTRU)
ROOT_TATTFILL_DEFINITIONVIRT(TSPHE)
ROOT_TATTFILL_DEFINITIONVIRT(TPCON)
ROOT_TATTFILL_DEFINITIONVIRT(TTUBE)
ROOT_TATTFILL_DEFINITIONVIRT(TBRIK)
ROOT_TATTFILL_DEFINITIONVIRT(TShape)
ROOT_TATTFILL_DEFINITIONVIRT(TArrow)
ROOT_TATTFILL_DEFINITIONVIRT(TCrown)
ROOT_TATTFILL_DEFINITIONVIRT(TArc)
ROOT_TATTFILL_DEFINITIONVIRT(TEllipse)
ROOT_TATTFILL_DEFINITIONVIRT(TGraphQQ)
ROOT_TATTFILL_DEFINITIONVIRT(TGraphPolar)
ROOT_TATTFILL_DEFINITIONVIRT(TGraphErrors)
ROOT_TATTFILL_DEFINITIONVIRT(TGraphBentErrors)
ROOT_TATTFILL_DEFINITIONVIRT(TCutG)
ROOT_TATTFILL_DEFINITIONVIRT(TGraphAsymmErrors)
ROOT_TATTFILL_DEFINITIONVIRT(TGraph)
ROOT_TATTFILL_DEFINITIONVIRT(TF1)
ROOT_TATTFILL_DEFINITIONVIRT(TAttFill)
ROOT_TATTIMAGE_DEFINITIONVIRT(TAttImage)
ROOT_TATTLINE_DEFINITIONVIRT(TSlider)
ROOT_TATTLINE_DEFINITIONVIRT(TEvePad)
ROOT_TATTLINE_DEFINITIONVIRT(TInspectCanvas)
ROOT_TATTLINE_DEFINITIONVIRT(TDialogCanvas)
ROOT_TATTLINE_DEFINITIONVIRT(TCanvas)
ROOT_TATTLINE_DEFINITIONVIRT(TGroupButton)
ROOT_TATTLINE_DEFINITIONVIRT(TButton)
ROOT_TATTLINE_DEFINITIONVIRT(TPad)
ROOT_TATTLINE_DEFINITIONVIRT(TVirtualPad)
ROOT_TATTLINE_DEFINITIONVIRT(TH3S)
ROOT_TATTLINE_DEFINITIONVIRT(TH3I)
ROOT_TATTLINE_DEFINITIONVIRT(TH3F)
ROOT_TATTLINE_DEFINITIONVIRT(TH3D)
ROOT_TATTLINE_DEFINITIONVIRT(TH3C)
ROOT_TATTLINE_DEFINITIONVIRT(TH2S)
ROOT_TATTLINE_DEFINITIONVIRT(TH2Poly)
ROOT_TATTLINE_DEFINITIONVIRT(TH2I)
ROOT_TATTLINE_DEFINITIONVIRT(TH2F)
ROOT_TATTLINE_DEFINITIONVIRT(TH2D)
ROOT_TATTLINE_DEFINITIONVIRT(TH2C)
ROOT_TATTLINE_DEFINITIONVIRT(TH1S)
ROOT_TATTLINE_DEFINITIONVIRT(TH1I)
ROOT_TATTLINE_DEFINITIONVIRT(TH1F)
ROOT_TATTLINE_DEFINITIONVIRT(TH1D)
ROOT_TATTLINE_DEFINITIONVIRT(TH1C)
ROOT_TATTLINE_DEFINITIONVIRT(TH3)
ROOT_TATTLINE_DEFINITIONVIRT(TH2)
ROOT_TATTLINE_DEFINITIONVIRT(TH1)
ROOT_TATTLINE_DEFINITIONVIRT(TLatex)
ROOT_TATTLINE_DEFINITIONVIRT(TEfficiency)
ROOT_TATTLINE_DEFINITIONVIRT(TCurlyArc)
ROOT_TATTLINE_DEFINITIONVIRT(TCurlyLine)
ROOT_TATTLINE_DEFINITIONVIRT(TPolyLine)
ROOT_TATTLINE_DEFINITIONVIRT(TTreeSQL)
ROOT_TATTLINE_DEFINITIONVIRT(TNtupleD)
ROOT_TATTLINE_DEFINITIONVIRT(TNtuple)
ROOT_TATTLINE_DEFINITIONVIRT(TChain)
ROOT_TATTLINE_DEFINITIONVIRT(TTree)
ROOT_TATTLINE_DEFINITIONVIRT(TSliderBox)
ROOT_TATTLINE_DEFINITIONVIRT(TFrame)
ROOT_TATTLINE_DEFINITIONVIRT(TWbox)
ROOT_TATTLINE_DEFINITIONVIRT(TPaveClass)
ROOT_TATTLINE_DEFINITIONVIRT(TPaveLabel)
ROOT_TATTLINE_DEFINITIONVIRT(TLegend)
ROOT_TATTLINE_DEFINITIONVIRT(TPavesText)
ROOT_TATTLINE_DEFINITIONVIRT(TPaveStats)
ROOT_TATTLINE_DEFINITIONVIRT(TDiamond)
ROOT_TATTLINE_DEFINITIONVIRT(TPaveText)
ROOT_TATTLINE_DEFINITIONVIRT(TPave)
ROOT_TATTLINE_DEFINITIONVIRT(TBox)
ROOT_TATTLINE_DEFINITIONVIRT(TXTRU)
ROOT_TATTLINE_DEFINITIONVIRT(TSPHE)
ROOT_TATTLINE_DEFINITIONVIRT(TPCON)
ROOT_TATTLINE_DEFINITIONVIRT(TTUBE)
ROOT_TATTLINE_DEFINITIONVIRT(TBRIK)
ROOT_TATTLINE_DEFINITIONVIRT(TShape)
ROOT_TATTLINE_DEFINITIONVIRT(TGaxis)
ROOT_TATTLINE_DEFINITIONVIRT(TArrow)
ROOT_TATTLINE_DEFINITIONVIRT(TLine)
ROOT_TATTLINE_DEFINITIONVIRT(TCrown)
ROOT_TATTLINE_DEFINITIONVIRT(TArc)
ROOT_TATTLINE_DEFINITIONVIRT(TEllipse)
ROOT_TATTLINE_DEFINITIONVIRT(TGraphQQ)
ROOT_TATTLINE_DEFINITIONVIRT(TGraphPolar)
ROOT_TATTLINE_DEFINITIONVIRT(TGraphErrors)
ROOT_TATTLINE_DEFINITIONVIRT(TGraphBentErrors)
ROOT_TATTLINE_DEFINITIONVIRT(TCutG)
ROOT_TATTLINE_DEFINITIONVIRT(TGraphAsymmErrors)
ROOT_TATTLINE_DEFINITIONVIRT(TGraph)
ROOT_TATTLINE_DEFINITIONVIRT(TF1)
ROOT_TATTLINE_DEFINITIONVIRT(TAttLine)
ROOT_TATTMARKER_DEFINITIONVIRT(TH3S)
ROOT_TATTMARKER_DEFINITIONVIRT(TH3I)
ROOT_TATTMARKER_DEFINITIONVIRT(TH3F)
ROOT_TATTMARKER_DEFINITIONVIRT(TH3D)
ROOT_TATTMARKER_DEFINITIONVIRT(TH3C)
ROOT_TATTMARKER_DEFINITIONVIRT(TH2S)
ROOT_TATTMARKER_DEFINITIONVIRT(TH2Poly)
ROOT_TATTMARKER_DEFINITIONVIRT(TH2I)
ROOT_TATTMARKER_DEFINITIONVIRT(TH2F)
ROOT_TATTMARKER_DEFINITIONVIRT(TH2D)
ROOT_TATTMARKER_DEFINITIONVIRT(TH2C)
ROOT_TATTMARKER_DEFINITIONVIRT(TH1S)
ROOT_TATTMARKER_DEFINITIONVIRT(TH1I)
ROOT_TATTMARKER_DEFINITIONVIRT(TH1F)
ROOT_TATTMARKER_DEFINITIONVIRT(TH1D)
ROOT_TATTMARKER_DEFINITIONVIRT(TH1C)
ROOT_TATTMARKER_DEFINITIONVIRT(TH3)
ROOT_TATTMARKER_DEFINITIONVIRT(TH2)
ROOT_TATTMARKER_DEFINITIONVIRT(TH1)
ROOT_TATTMARKER_DEFINITIONVIRT(TEfficiency)
ROOT_TATTMARKER_DEFINITIONVIRT(TTreeSQL)
ROOT_TATTMARKER_DEFINITIONVIRT(TNtupleD)
ROOT_TATTMARKER_DEFINITIONVIRT(TNtuple)
ROOT_TATTMARKER_DEFINITIONVIRT(TChain)
ROOT_TATTMARKER_DEFINITIONVIRT(TTree)
ROOT_TATTMARKER_DEFINITIONVIRT(TGraphQQ)
ROOT_TATTMARKER_DEFINITIONVIRT(TGraphPolar)
ROOT_TATTMARKER_DEFINITIONVIRT(TGraphErrors)
ROOT_TATTMARKER_DEFINITIONVIRT(TGraphBentErrors)
ROOT_TATTMARKER_DEFINITIONVIRT(TCutG)
ROOT_TATTMARKER_DEFINITIONVIRT(TGraphAsymmErrors)
ROOT_TATTMARKER_DEFINITIONVIRT(TGraph)
ROOT_TATTMARKER_DEFINITIONVIRT(TAttMarker)
ROOT_TATTPAD_DEFINITIONVIRT(TSlider)
ROOT_TATTPAD_DEFINITIONVIRT(TEvePad)
ROOT_TATTPAD_DEFINITIONVIRT(TInspectCanvas)
ROOT_TATTPAD_DEFINITIONVIRT(TDialogCanvas)
ROOT_TATTPAD_DEFINITIONVIRT(TCanvas)
ROOT_TATTPAD_DEFINITIONVIRT(TGroupButton)
ROOT_TATTPAD_DEFINITIONVIRT(TButton)
ROOT_TATTPAD_DEFINITIONVIRT(TPad)
ROOT_TATTPAD_DEFINITIONVIRT(TVirtualPad)
ROOT_TATTPAD_DEFINITIONVIRT(TAttPad)
ROOT_TATTPARTICLE_DEFINITIONVIRT(TAttParticle)
ROOT_TATTTEXT_DEFINITIONVIRT(TInspectCanvas)
ROOT_TATTTEXT_DEFINITIONVIRT(TDialogCanvas)
ROOT_TATTTEXT_DEFINITIONVIRT(TGroupButton)
ROOT_TATTTEXT_DEFINITIONVIRT(TButton)
ROOT_TATTTEXT_DEFINITIONVIRT(TText)
ROOT_TATTTEXT_DEFINITIONVIRT(TLatex)
ROOT_TATTTEXT_DEFINITIONVIRT(TPaveClass)
ROOT_TATTTEXT_DEFINITIONVIRT(TPaveLabel)
ROOT_TATTTEXT_DEFINITIONVIRT(TLegend)
ROOT_TATTTEXT_DEFINITIONVIRT(TPavesText)
ROOT_TATTTEXT_DEFINITIONVIRT(TPaveStats)
ROOT_TATTTEXT_DEFINITIONVIRT(TDiamond)
ROOT_TATTTEXT_DEFINITIONVIRT(TPaveText)
ROOT_TATTTEXT_DEFINITIONVIRT(TGaxis)
ROOT_TATTTEXT_DEFINITIONVIRT(TAttText)
ROOT_TAXIS_DEFINITIONVIRT(TAxis)
ROOT_TBRIK_DEFINITIONVIRT(TBRIK)
ROOT_TBOX_DEFINITIONVIRT(TSliderBox)
ROOT_TBOX_DEFINITIONVIRT(TFrame)
ROOT_TBOX_DEFINITIONVIRT(TWbox)
ROOT_TBOX_DEFINITIONVIRT(TPaveClass)
ROOT_TBOX_DEFINITIONVIRT(TPaveLabel)
ROOT_TBOX_DEFINITIONVIRT(TLegend)
ROOT_TBOX_DEFINITIONVIRT(TPavesText)
ROOT_TBOX_DEFINITIONVIRT(TPaveStats)
ROOT_TBOX_DEFINITIONVIRT(TDiamond)
ROOT_TBOX_DEFINITIONVIRT(TPaveText)
ROOT_TBOX_DEFINITIONVIRT(TPave)
ROOT_TBOX_DEFINITIONVIRT(TBox)
ROOT_TBRANCH_DEFINITIONVIRT(TBranch)
ROOT_TBUTTON_DEFINITIONVIRT(TGroupButton)
ROOT_TBUTTON_DEFINITIONVIRT(TButton)
ROOT_TCANVAS_DEFINITIONVIRT(TInspectCanvas)
ROOT_TCANVAS_DEFINITIONVIRT(TDialogCanvas)
ROOT_TCANVAS_DEFINITIONVIRT(TCanvas)
ROOT_TCHAIN_DEFINITIONVIRT(TChain)
ROOT_TCLASS_DEFINITIONVIRT(TClass)
ROOT_TCOLLECTION_DEFINITIONVIRT(TObjArray)
ROOT_TCOLLECTION_DEFINITIONVIRT(TSeqCollection)
ROOT_TCOLLECTION_DEFINITIONVIRT(TCollection)
ROOT_TCROWN_DEFINITIONVIRT(TCrown)
ROOT_TCURLYARC_DEFINITIONVIRT(TCurlyArc)
ROOT_TCURLYLINE_DEFINITIONVIRT(TCurlyArc)
ROOT_TCURLYLINE_DEFINITIONVIRT(TCurlyLine)
ROOT_TCUTG_DEFINITIONVIRT(TCutG)
ROOT_TDIALOGCANVAS_DEFINITIONVIRT(TDialogCanvas)
ROOT_TDIAMOND_DEFINITIONVIRT(TDiamond)
ROOT_TDICTIONARY_DEFINITIONVIRT(TClass)
ROOT_TDIRECTORY_DEFINITIONVIRT(TFile)
ROOT_TDIRECTORY_DEFINITIONVIRT(TDirectoryFile)
ROOT_TDIRECTORY_DEFINITIONVIRT(TDirectory)
ROOT_TDIRECTORYFILE_DEFINITIONVIRT(TFile)
ROOT_TDIRECTORYFILE_DEFINITIONVIRT(TDirectoryFile)
ROOT_TEFFICIENCY_DEFINITIONVIRT(TEfficiency)
ROOT_TELLIPSE_DEFINITIONVIRT(TCrown)
ROOT_TELLIPSE_DEFINITIONVIRT(TArc)
ROOT_TELLIPSE_DEFINITIONVIRT(TEllipse)
ROOT_TEVEPAD_DEFINITIONVIRT(TEvePad)
ROOT_TF1_DEFINITIONVIRT(TF1)
ROOT_TFILE_DEFINITIONVIRT(TFile)
ROOT_TFORMULA_DEFINITIONVIRT(TF1)
ROOT_TFORMULA_DEFINITIONVIRT(TFormula)
ROOT_TFRAME_DEFINITIONVIRT(TFrame)
ROOT_TGAXIS_DEFINITIONVIRT(TGaxis)
ROOT_TGRAPH_DEFINITIONVIRT(TGraphQQ)
ROOT_TGRAPH_DEFINITIONVIRT(TGraphPolar)
ROOT_TGRAPH_DEFINITIONVIRT(TGraphErrors)
ROOT_TGRAPH_DEFINITIONVIRT(TGraphBentErrors)
ROOT_TGRAPH_DEFINITIONVIRT(TCutG)
ROOT_TGRAPH_DEFINITIONVIRT(TGraphAsymmErrors)
ROOT_TGRAPH_DEFINITIONVIRT(TGraph)
ROOT_TGRAPHASYMMERRORS_DEFINITIONVIRT(TGraphAsymmErrors)
ROOT_TGRAPHBENTERRORS_DEFINITIONVIRT(TGraphBentErrors)
ROOT_TGRAPHERRORS_DEFINITIONVIRT(TGraphPolar)
ROOT_TGRAPHERRORS_DEFINITIONVIRT(TGraphErrors)
ROOT_TGRAPHPOLAR_DEFINITIONVIRT(TGraphPolar)
ROOT_TGRAPHQQ_DEFINITIONVIRT(TGraphQQ)
ROOT_TGROUPBUTTON_DEFINITIONVIRT(TGroupButton)
ROOT_TH1_DEFINITIONVIRT(TH3S)
ROOT_TH1_DEFINITIONVIRT(TH3I)
ROOT_TH1_DEFINITIONVIRT(TH3F)
ROOT_TH1_DEFINITIONVIRT(TH3D)
ROOT_TH1_DEFINITIONVIRT(TH3C)
ROOT_TH1_DEFINITIONVIRT(TH2S)
ROOT_TH1_DEFINITIONVIRT(TH2Poly)
ROOT_TH1_DEFINITIONVIRT(TH2I)
ROOT_TH1_DEFINITIONVIRT(TH2F)
ROOT_TH1_DEFINITIONVIRT(TH2D)
ROOT_TH1_DEFINITIONVIRT(TH2C)
ROOT_TH1_DEFINITIONVIRT(TH1S)
ROOT_TH1_DEFINITIONVIRT(TH1I)
ROOT_TH1_DEFINITIONVIRT(TH1F)
ROOT_TH1_DEFINITIONVIRT(TH1D)
ROOT_TH1_DEFINITIONVIRT(TH1C)
ROOT_TH1_DEFINITIONVIRT(TH3)
ROOT_TH1_DEFINITIONVIRT(TH2)
ROOT_TH1_DEFINITIONVIRT(TH1)
ROOT_TH1C_DEFINITIONVIRT(TH1C)
ROOT_TH1D_DEFINITIONVIRT(TH1D)
ROOT_TH1F_DEFINITIONVIRT(TH1F)
ROOT_TH1I_DEFINITIONVIRT(TH1I)
ROOT_TH1S_DEFINITIONVIRT(TH1S)
ROOT_TH2_DEFINITIONVIRT(TH2S)
ROOT_TH2_DEFINITIONVIRT(TH2Poly)
ROOT_TH2_DEFINITIONVIRT(TH2I)
ROOT_TH2_DEFINITIONVIRT(TH2F)
ROOT_TH2_DEFINITIONVIRT(TH2D)
ROOT_TH2_DEFINITIONVIRT(TH2C)
ROOT_TH2_DEFINITIONVIRT(TH2)
ROOT_TH2C_DEFINITIONVIRT(TH2C)
ROOT_TH2D_DEFINITIONVIRT(TH2D)
ROOT_TH2F_DEFINITIONVIRT(TH2F)
ROOT_TH2I_DEFINITIONVIRT(TH2I)
ROOT_TH2POLY_DEFINITIONVIRT(TH2Poly)
ROOT_TH2S_DEFINITIONVIRT(TH2S)
ROOT_TH3_DEFINITIONVIRT(TH3S)
ROOT_TH3_DEFINITIONVIRT(TH3I)
ROOT_TH3_DEFINITIONVIRT(TH3F)
ROOT_TH3_DEFINITIONVIRT(TH3D)
ROOT_TH3_DEFINITIONVIRT(TH3C)
ROOT_TH3_DEFINITIONVIRT(TH3)
ROOT_TH3C_DEFINITIONVIRT(TH3C)
ROOT_TH3D_DEFINITIONVIRT(TH3D)
ROOT_TH3F_DEFINITIONVIRT(TH3F)
ROOT_TH3I_DEFINITIONVIRT(TH3I)
ROOT_TH3S_DEFINITIONVIRT(TH3S)
ROOT_THSTACK_DEFINITIONVIRT(THStack)
ROOT_TINSPECTCANVAS_DEFINITIONVIRT(TInspectCanvas)
ROOT_TLATEX_DEFINITIONVIRT(TLatex)
ROOT_TLEGEND_DEFINITIONVIRT(TLegend)
ROOT_TLINE_DEFINITIONVIRT(TGaxis)
ROOT_TLINE_DEFINITIONVIRT(TArrow)
ROOT_TLINE_DEFINITIONVIRT(TLine)
ROOT_TNAMED_DEFINITIONVIRT(TRandom)
ROOT_TNAMED_DEFINITIONVIRT(TH3S)
ROOT_TNAMED_DEFINITIONVIRT(TH3I)
ROOT_TNAMED_DEFINITIONVIRT(TH3F)
ROOT_TNAMED_DEFINITIONVIRT(TH3D)
ROOT_TNAMED_DEFINITIONVIRT(TH3C)
ROOT_TNAMED_DEFINITIONVIRT(TH2S)
ROOT_TNAMED_DEFINITIONVIRT(TH2Poly)
ROOT_TNAMED_DEFINITIONVIRT(TH2I)
ROOT_TNAMED_DEFINITIONVIRT(TH2F)
ROOT_TNAMED_DEFINITIONVIRT(TH2D)
ROOT_TNAMED_DEFINITIONVIRT(TH2C)
ROOT_TNAMED_DEFINITIONVIRT(TH1S)
ROOT_TNAMED_DEFINITIONVIRT(TH1I)
ROOT_TNAMED_DEFINITIONVIRT(TH1F)
ROOT_TNAMED_DEFINITIONVIRT(TH1D)
ROOT_TNAMED_DEFINITIONVIRT(TH1C)
ROOT_TNAMED_DEFINITIONVIRT(TH3)
ROOT_TNAMED_DEFINITIONVIRT(TH2)
ROOT_TNAMED_DEFINITIONVIRT(TH1)
ROOT_TNAMED_DEFINITIONVIRT(TBranch)
ROOT_TNAMED_DEFINITIONVIRT(TFile)
ROOT_TNAMED_DEFINITIONVIRT(TDirectoryFile)
ROOT_TNAMED_DEFINITIONVIRT(TDirectory)
ROOT_TNAMED_DEFINITIONVIRT(TText)
ROOT_TNAMED_DEFINITIONVIRT(TLatex)
ROOT_TNAMED_DEFINITIONVIRT(TAxis)
ROOT_TNAMED_DEFINITIONVIRT(TEfficiency)
ROOT_TNAMED_DEFINITIONVIRT(TTreeSQL)
ROOT_TNAMED_DEFINITIONVIRT(TNtupleD)
ROOT_TNAMED_DEFINITIONVIRT(TNtuple)
ROOT_TNAMED_DEFINITIONVIRT(TChain)
ROOT_TNAMED_DEFINITIONVIRT(TTree)
ROOT_TNAMED_DEFINITIONVIRT(TXTRU)
ROOT_TNAMED_DEFINITIONVIRT(TSPHE)
ROOT_TNAMED_DEFINITIONVIRT(TPCON)
ROOT_TNAMED_DEFINITIONVIRT(TTUBE)
ROOT_TNAMED_DEFINITIONVIRT(TBRIK)
ROOT_TNAMED_DEFINITIONVIRT(TShape)
ROOT_TNAMED_DEFINITIONVIRT(TGraphQQ)
ROOT_TNAMED_DEFINITIONVIRT(TGraphPolar)
ROOT_TNAMED_DEFINITIONVIRT(TGraphErrors)
ROOT_TNAMED_DEFINITIONVIRT(TGraphBentErrors)
ROOT_TNAMED_DEFINITIONVIRT(TCutG)
ROOT_TNAMED_DEFINITIONVIRT(TGraphAsymmErrors)
ROOT_TNAMED_DEFINITIONVIRT(TGraph)
ROOT_TNAMED_DEFINITIONVIRT(TF1)
ROOT_TNAMED_DEFINITIONVIRT(THStack)
ROOT_TNAMED_DEFINITIONVIRT(TAttParticle)
ROOT_TNAMED_DEFINITIONVIRT(TFormula)
ROOT_TNAMED_DEFINITIONVIRT(TClass)
ROOT_TNAMED_DEFINITIONVIRT(TNamed)
ROOT_TNTUPLE_DEFINITIONVIRT(TNtuple)
ROOT_TNTUPLED_DEFINITIONVIRT(TNtupleD)
ROOT_TOBJARRAY_DEFINITIONVIRT(TObjArray)
ROOT_TOBJECT_DEFINITIONVIRT(TObjArray)
ROOT_TOBJECT_DEFINITIONVIRT(TSeqCollection)
ROOT_TOBJECT_DEFINITIONVIRT(TCollection)
ROOT_TOBJECT_DEFINITIONVIRT(TRandom)
ROOT_TOBJECT_DEFINITIONVIRT(TRint)
ROOT_TOBJECT_DEFINITIONVIRT(TApplication)
ROOT_TOBJECT_DEFINITIONVIRT(TSlider)
ROOT_TOBJECT_DEFINITIONVIRT(TEvePad)
ROOT_TOBJECT_DEFINITIONVIRT(TInspectCanvas)
ROOT_TOBJECT_DEFINITIONVIRT(TDialogCanvas)
ROOT_TOBJECT_DEFINITIONVIRT(TCanvas)
ROOT_TOBJECT_DEFINITIONVIRT(TGroupButton)
ROOT_TOBJECT_DEFINITIONVIRT(TButton)
ROOT_TOBJECT_DEFINITIONVIRT(TPad)
ROOT_TOBJECT_DEFINITIONVIRT(TVirtualPad)
ROOT_TOBJECT_DEFINITIONVIRT(TH3S)
ROOT_TOBJECT_DEFINITIONVIRT(TH3I)
ROOT_TOBJECT_DEFINITIONVIRT(TH3F)
ROOT_TOBJECT_DEFINITIONVIRT(TH3D)
ROOT_TOBJECT_DEFINITIONVIRT(TH3C)
ROOT_TOBJECT_DEFINITIONVIRT(TH2S)
ROOT_TOBJECT_DEFINITIONVIRT(TH2Poly)
ROOT_TOBJECT_DEFINITIONVIRT(TH2I)
ROOT_TOBJECT_DEFINITIONVIRT(TH2F)
ROOT_TOBJECT_DEFINITIONVIRT(TH2D)
ROOT_TOBJECT_DEFINITIONVIRT(TH2C)
ROOT_TOBJECT_DEFINITIONVIRT(TH1S)
ROOT_TOBJECT_DEFINITIONVIRT(TH1I)
ROOT_TOBJECT_DEFINITIONVIRT(TH1F)
ROOT_TOBJECT_DEFINITIONVIRT(TH1D)
ROOT_TOBJECT_DEFINITIONVIRT(TH1C)
ROOT_TOBJECT_DEFINITIONVIRT(TH3)
ROOT_TOBJECT_DEFINITIONVIRT(TH2)
ROOT_TOBJECT_DEFINITIONVIRT(TH1)
ROOT_TOBJECT_DEFINITIONVIRT(TTreePlayer)
ROOT_TOBJECT_DEFINITIONVIRT(TVirtualTreePlayer)
ROOT_TOBJECT_DEFINITIONVIRT(TBranch)
ROOT_TOBJECT_DEFINITIONVIRT(TFile)
ROOT_TOBJECT_DEFINITIONVIRT(TDirectoryFile)
ROOT_TOBJECT_DEFINITIONVIRT(TDirectory)
ROOT_TOBJECT_DEFINITIONVIRT(TText)
ROOT_TOBJECT_DEFINITIONVIRT(TLatex)
ROOT_TOBJECT_DEFINITIONVIRT(TAxis)
ROOT_TOBJECT_DEFINITIONVIRT(TEfficiency)
ROOT_TOBJECT_DEFINITIONVIRT(TCurlyArc)
ROOT_TOBJECT_DEFINITIONVIRT(TCurlyLine)
ROOT_TOBJECT_DEFINITIONVIRT(TPolyLine)
ROOT_TOBJECT_DEFINITIONVIRT(TTreeSQL)
ROOT_TOBJECT_DEFINITIONVIRT(TNtupleD)
ROOT_TOBJECT_DEFINITIONVIRT(TNtuple)
ROOT_TOBJECT_DEFINITIONVIRT(TChain)
ROOT_TOBJECT_DEFINITIONVIRT(TTree)
ROOT_TOBJECT_DEFINITIONVIRT(TSliderBox)
ROOT_TOBJECT_DEFINITIONVIRT(TFrame)
ROOT_TOBJECT_DEFINITIONVIRT(TWbox)
ROOT_TOBJECT_DEFINITIONVIRT(TPaveClass)
ROOT_TOBJECT_DEFINITIONVIRT(TPaveLabel)
ROOT_TOBJECT_DEFINITIONVIRT(TLegend)
ROOT_TOBJECT_DEFINITIONVIRT(TPavesText)
ROOT_TOBJECT_DEFINITIONVIRT(TPaveStats)
ROOT_TOBJECT_DEFINITIONVIRT(TDiamond)
ROOT_TOBJECT_DEFINITIONVIRT(TPaveText)
ROOT_TOBJECT_DEFINITIONVIRT(TPave)
ROOT_TOBJECT_DEFINITIONVIRT(TBox)
ROOT_TOBJECT_DEFINITIONVIRT(TXTRU)
ROOT_TOBJECT_DEFINITIONVIRT(TSPHE)
ROOT_TOBJECT_DEFINITIONVIRT(TPCON)
ROOT_TOBJECT_DEFINITIONVIRT(TTUBE)
ROOT_TOBJECT_DEFINITIONVIRT(TBRIK)
ROOT_TOBJECT_DEFINITIONVIRT(TShape)
ROOT_TOBJECT_DEFINITIONVIRT(TGaxis)
ROOT_TOBJECT_DEFINITIONVIRT(TArrow)
ROOT_TOBJECT_DEFINITIONVIRT(TLine)
ROOT_TOBJECT_DEFINITIONVIRT(TCrown)
ROOT_TOBJECT_DEFINITIONVIRT(TArc)
ROOT_TOBJECT_DEFINITIONVIRT(TEllipse)
ROOT_TOBJECT_DEFINITIONVIRT(TGraphQQ)
ROOT_TOBJECT_DEFINITIONVIRT(TGraphPolar)
ROOT_TOBJECT_DEFINITIONVIRT(TGraphErrors)
ROOT_TOBJECT_DEFINITIONVIRT(TGraphBentErrors)
ROOT_TOBJECT_DEFINITIONVIRT(TCutG)
ROOT_TOBJECT_DEFINITIONVIRT(TGraphAsymmErrors)
ROOT_TOBJECT_DEFINITIONVIRT(TGraph)
ROOT_TOBJECT_DEFINITIONVIRT(TF1)
ROOT_TOBJECT_DEFINITIONVIRT(THStack)
ROOT_TOBJECT_DEFINITIONVIRT(TAttParticle)
ROOT_TOBJECT_DEFINITIONVIRT(TFormula)
ROOT_TOBJECT_DEFINITIONVIRT(TClass)
ROOT_TOBJECT_DEFINITIONVIRT(TNamed)
ROOT_TOBJECT_DEFINITIONVIRT(TObject)
ROOT_TPCON_DEFINITIONVIRT(TPCON)
ROOT_TPAD_DEFINITIONVIRT(TSlider)
ROOT_TPAD_DEFINITIONVIRT(TEvePad)
ROOT_TPAD_DEFINITIONVIRT(TInspectCanvas)
ROOT_TPAD_DEFINITIONVIRT(TDialogCanvas)
ROOT_TPAD_DEFINITIONVIRT(TCanvas)
ROOT_TPAD_DEFINITIONVIRT(TGroupButton)
ROOT_TPAD_DEFINITIONVIRT(TButton)
ROOT_TPAD_DEFINITIONVIRT(TPad)
ROOT_TPAVE_DEFINITIONVIRT(TPaveClass)
ROOT_TPAVE_DEFINITIONVIRT(TPaveLabel)
ROOT_TPAVE_DEFINITIONVIRT(TLegend)
ROOT_TPAVE_DEFINITIONVIRT(TPavesText)
ROOT_TPAVE_DEFINITIONVIRT(TPaveStats)
ROOT_TPAVE_DEFINITIONVIRT(TDiamond)
ROOT_TPAVE_DEFINITIONVIRT(TPaveText)
ROOT_TPAVE_DEFINITIONVIRT(TPave)
ROOT_TPAVECLASS_DEFINITIONVIRT(TPaveClass)
ROOT_TPAVELABEL_DEFINITIONVIRT(TPaveClass)
ROOT_TPAVELABEL_DEFINITIONVIRT(TPaveLabel)
ROOT_TPAVESTATS_DEFINITIONVIRT(TPaveStats)
ROOT_TPAVETEXT_DEFINITIONVIRT(TPavesText)
ROOT_TPAVETEXT_DEFINITIONVIRT(TPaveStats)
ROOT_TPAVETEXT_DEFINITIONVIRT(TDiamond)
ROOT_TPAVETEXT_DEFINITIONVIRT(TPaveText)
ROOT_TPAVESTEXT_DEFINITIONVIRT(TPavesText)
ROOT_TPOLYLINE_DEFINITIONVIRT(TCurlyArc)
ROOT_TPOLYLINE_DEFINITIONVIRT(TCurlyLine)
ROOT_TPOLYLINE_DEFINITIONVIRT(TPolyLine)
ROOT_TQOBJECT_DEFINITIONVIRT(TRint)
ROOT_TQOBJECT_DEFINITIONVIRT(TApplication)
ROOT_TQOBJECT_DEFINITIONVIRT(TSlider)
ROOT_TQOBJECT_DEFINITIONVIRT(TEvePad)
ROOT_TQOBJECT_DEFINITIONVIRT(TInspectCanvas)
ROOT_TQOBJECT_DEFINITIONVIRT(TDialogCanvas)
ROOT_TQOBJECT_DEFINITIONVIRT(TCanvas)
ROOT_TQOBJECT_DEFINITIONVIRT(TGroupButton)
ROOT_TQOBJECT_DEFINITIONVIRT(TButton)
ROOT_TQOBJECT_DEFINITIONVIRT(TPad)
ROOT_TQOBJECT_DEFINITIONVIRT(TVirtualPad)
ROOT_TQOBJECT_DEFINITIONVIRT(TQObject)
ROOT_TRANDOM_DEFINITIONVIRT(TRandom)
ROOT_TRINT_DEFINITIONVIRT(TRint)
ROOT_TSPHE_DEFINITIONVIRT(TSPHE)
ROOT_TSEQCOLLECTION_DEFINITIONVIRT(TObjArray)
ROOT_TSEQCOLLECTION_DEFINITIONVIRT(TSeqCollection)
ROOT_TSHAPE_DEFINITIONVIRT(TXTRU)
ROOT_TSHAPE_DEFINITIONVIRT(TSPHE)
ROOT_TSHAPE_DEFINITIONVIRT(TPCON)
ROOT_TSHAPE_DEFINITIONVIRT(TTUBE)
ROOT_TSHAPE_DEFINITIONVIRT(TBRIK)
ROOT_TSHAPE_DEFINITIONVIRT(TShape)
ROOT_TSLIDER_DEFINITIONVIRT(TSlider)
ROOT_TSLIDERBOX_DEFINITIONVIRT(TSliderBox)
ROOT_TTUBE_DEFINITIONVIRT(TTUBE)
ROOT_TTEXT_DEFINITIONVIRT(TText)
ROOT_TTEXT_DEFINITIONVIRT(TLatex)
ROOT_TTREE_DEFINITIONVIRT(TTreeSQL)
ROOT_TTREE_DEFINITIONVIRT(TNtupleD)
ROOT_TTREE_DEFINITIONVIRT(TNtuple)
ROOT_TTREE_DEFINITIONVIRT(TChain)
ROOT_TTREE_DEFINITIONVIRT(TTree)
ROOT_TTREEPLAYER_DEFINITIONVIRT(TTreePlayer)
ROOT_TTREESQL_DEFINITIONVIRT(TTreeSQL)
ROOT_TVIRTUALPAD_DEFINITIONVIRT(TSlider)
ROOT_TVIRTUALPAD_DEFINITIONVIRT(TEvePad)
ROOT_TVIRTUALPAD_DEFINITIONVIRT(TInspectCanvas)
ROOT_TVIRTUALPAD_DEFINITIONVIRT(TDialogCanvas)
ROOT_TVIRTUALPAD_DEFINITIONVIRT(TCanvas)
ROOT_TVIRTUALPAD_DEFINITIONVIRT(TGroupButton)
ROOT_TVIRTUALPAD_DEFINITIONVIRT(TButton)
ROOT_TVIRTUALPAD_DEFINITIONVIRT(TPad)
ROOT_TVIRTUALPAD_DEFINITIONVIRT(TVirtualPad)
ROOT_TVIRTUALTREEPLAYER_DEFINITIONVIRT(TTreePlayer)
ROOT_TVIRTUALTREEPLAYER_DEFINITIONVIRT(TVirtualTreePlayer)
ROOT_TWBOX_DEFINITIONVIRT(TSliderBox)
ROOT_TWBOX_DEFINITIONVIRT(TFrame)
ROOT_TWBOX_DEFINITIONVIRT(TWbox)
ROOT_TXTRU_DEFINITIONVIRT(TXTRU)


ROOT_DELETABLE_DEFINITIONNONVIRT(Deletable)
ROOT_TOBJECT_DEFINITIONNONVIRT(TObject)
ROOT_TNAMED_DEFINITIONNONVIRT(TNamed)
ROOT_TDICTIONARY_DEFINITIONNONVIRT(TDictionary)
ROOT_TCLASS_DEFINITIONNONVIRT(TClass)
ROOT_TFORMULA_DEFINITIONNONVIRT(TFormula)
ROOT_TATT3D_DEFINITIONNONVIRT(TAtt3D)
ROOT_TATTAXIS_DEFINITIONNONVIRT(TAttAxis)
ROOT_TATTBBOX_DEFINITIONNONVIRT(TAttBBox)
ROOT_TATTCANVAS_DEFINITIONNONVIRT(TAttCanvas)
ROOT_TATTFILL_DEFINITIONNONVIRT(TAttFill)
ROOT_TATTIMAGE_DEFINITIONNONVIRT(TAttImage)
ROOT_TATTLINE_DEFINITIONNONVIRT(TAttLine)
ROOT_TATTMARKER_DEFINITIONNONVIRT(TAttMarker)
ROOT_TATTPAD_DEFINITIONNONVIRT(TAttPad)
ROOT_TATTPARTICLE_DEFINITIONNONVIRT(TAttParticle)
ROOT_TATTTEXT_DEFINITIONNONVIRT(TAttText)
ROOT_THSTACK_DEFINITIONNONVIRT(THStack)
ROOT_TF1_DEFINITIONNONVIRT(TF1)
ROOT_TGRAPH_DEFINITIONNONVIRT(TGraph)
ROOT_TGRAPHASYMMERRORS_DEFINITIONNONVIRT(TGraphAsymmErrors)
ROOT_TCUTG_DEFINITIONNONVIRT(TCutG)
ROOT_TGRAPHBENTERRORS_DEFINITIONNONVIRT(TGraphBentErrors)
ROOT_TGRAPHERRORS_DEFINITIONNONVIRT(TGraphErrors)
ROOT_TGRAPHPOLAR_DEFINITIONNONVIRT(TGraphPolar)
ROOT_TGRAPHQQ_DEFINITIONNONVIRT(TGraphQQ)
ROOT_TELLIPSE_DEFINITIONNONVIRT(TEllipse)
ROOT_TARC_DEFINITIONNONVIRT(TArc)
ROOT_TCROWN_DEFINITIONNONVIRT(TCrown)
ROOT_TLINE_DEFINITIONNONVIRT(TLine)
ROOT_TARROW_DEFINITIONNONVIRT(TArrow)
ROOT_TGAXIS_DEFINITIONNONVIRT(TGaxis)
ROOT_TSHAPE_DEFINITIONNONVIRT(TShape)
ROOT_TBRIK_DEFINITIONNONVIRT(TBRIK)
ROOT_TTUBE_DEFINITIONNONVIRT(TTUBE)
ROOT_TPCON_DEFINITIONNONVIRT(TPCON)
ROOT_TSPHE_DEFINITIONNONVIRT(TSPHE)
ROOT_TXTRU_DEFINITIONNONVIRT(TXTRU)
ROOT_TBOX_DEFINITIONNONVIRT(TBox)
ROOT_TPAVE_DEFINITIONNONVIRT(TPave)
ROOT_TPAVETEXT_DEFINITIONNONVIRT(TPaveText)
ROOT_TDIAMOND_DEFINITIONNONVIRT(TDiamond)
ROOT_TPAVESTATS_DEFINITIONNONVIRT(TPaveStats)
ROOT_TPAVESTEXT_DEFINITIONNONVIRT(TPavesText)
ROOT_TLEGEND_DEFINITIONNONVIRT(TLegend)
ROOT_TPAVELABEL_DEFINITIONNONVIRT(TPaveLabel)
ROOT_TPAVECLASS_DEFINITIONNONVIRT(TPaveClass)
ROOT_TWBOX_DEFINITIONNONVIRT(TWbox)
ROOT_TFRAME_DEFINITIONNONVIRT(TFrame)
ROOT_TSLIDERBOX_DEFINITIONNONVIRT(TSliderBox)
ROOT_TTREE_DEFINITIONNONVIRT(TTree)
ROOT_TCHAIN_DEFINITIONNONVIRT(TChain)
ROOT_TNTUPLE_DEFINITIONNONVIRT(TNtuple)
ROOT_TNTUPLED_DEFINITIONNONVIRT(TNtupleD)
ROOT_TTREESQL_DEFINITIONNONVIRT(TTreeSQL)
ROOT_TPOLYLINE_DEFINITIONNONVIRT(TPolyLine)
ROOT_TCURLYLINE_DEFINITIONNONVIRT(TCurlyLine)
ROOT_TCURLYARC_DEFINITIONNONVIRT(TCurlyArc)
ROOT_TEFFICIENCY_DEFINITIONNONVIRT(TEfficiency)
ROOT_TAXIS_DEFINITIONNONVIRT(TAxis)
ROOT_TLATEX_DEFINITIONNONVIRT(TLatex)
ROOT_TTEXT_DEFINITIONNONVIRT(TText)
ROOT_TDIRECTORY_DEFINITIONNONVIRT(TDirectory)
ROOT_TDIRECTORYFILE_DEFINITIONNONVIRT(TDirectoryFile)
ROOT_TFILE_DEFINITIONNONVIRT(TFile)
ROOT_TBRANCH_DEFINITIONNONVIRT(TBranch)
ROOT_TVIRTUALTREEPLAYER_DEFINITIONNONVIRT(TVirtualTreePlayer)
ROOT_TTREEPLAYER_DEFINITIONNONVIRT(TTreePlayer)
ROOT_TARRAY_DEFINITIONNONVIRT(TArray)
ROOT_TARRAYC_DEFINITIONNONVIRT(TArrayC)
ROOT_TARRAYD_DEFINITIONNONVIRT(TArrayD)
ROOT_TARRAYF_DEFINITIONNONVIRT(TArrayF)
ROOT_TARRAYI_DEFINITIONNONVIRT(TArrayI)
ROOT_TARRAYL_DEFINITIONNONVIRT(TArrayL)
ROOT_TARRAYL64_DEFINITIONNONVIRT(TArrayL64)
ROOT_TARRAYS_DEFINITIONNONVIRT(TArrayS)
ROOT_TH1_DEFINITIONNONVIRT(TH1)
ROOT_TH2_DEFINITIONNONVIRT(TH2)
ROOT_TH3_DEFINITIONNONVIRT(TH3)
ROOT_TH1C_DEFINITIONNONVIRT(TH1C)
ROOT_TH1D_DEFINITIONNONVIRT(TH1D)
ROOT_TH1F_DEFINITIONNONVIRT(TH1F)
ROOT_TH1I_DEFINITIONNONVIRT(TH1I)
ROOT_TH1S_DEFINITIONNONVIRT(TH1S)
ROOT_TH2C_DEFINITIONNONVIRT(TH2C)
ROOT_TH2D_DEFINITIONNONVIRT(TH2D)
ROOT_TH2F_DEFINITIONNONVIRT(TH2F)
ROOT_TH2I_DEFINITIONNONVIRT(TH2I)
ROOT_TH2POLY_DEFINITIONNONVIRT(TH2Poly)
ROOT_TH2S_DEFINITIONNONVIRT(TH2S)
ROOT_TH3C_DEFINITIONNONVIRT(TH3C)
ROOT_TH3D_DEFINITIONNONVIRT(TH3D)
ROOT_TH3F_DEFINITIONNONVIRT(TH3F)
ROOT_TH3I_DEFINITIONNONVIRT(TH3I)
ROOT_TH3S_DEFINITIONNONVIRT(TH3S)
ROOT_TQOBJECT_DEFINITIONNONVIRT(TQObject)
ROOT_TVIRTUALPAD_DEFINITIONNONVIRT(TVirtualPad)
ROOT_TPAD_DEFINITIONNONVIRT(TPad)
ROOT_TBUTTON_DEFINITIONNONVIRT(TButton)
ROOT_TGROUPBUTTON_DEFINITIONNONVIRT(TGroupButton)
ROOT_TCANVAS_DEFINITIONNONVIRT(TCanvas)
ROOT_TDIALOGCANVAS_DEFINITIONNONVIRT(TDialogCanvas)
ROOT_TINSPECTCANVAS_DEFINITIONNONVIRT(TInspectCanvas)
ROOT_TEVEPAD_DEFINITIONNONVIRT(TEvePad)
ROOT_TSLIDER_DEFINITIONNONVIRT(TSlider)
ROOT_TAPPLICATION_DEFINITIONNONVIRT(TApplication)
ROOT_TRINT_DEFINITIONNONVIRT(TRint)
ROOT_TRANDOM_DEFINITIONNONVIRT(TRandom)
ROOT_TCOLLECTION_DEFINITIONNONVIRT(TCollection)
ROOT_TSEQCOLLECTION_DEFINITIONNONVIRT(TSeqCollection)
ROOT_TOBJARRAY_DEFINITIONNONVIRT(TObjArray)